@netpad/mcp-server 2.0.0 → 2.2.0

package/dist/index.js

@@ -16567,104 +16567,6 @@ var APPLICATION_TEMPLATES = {
     }
   }
 };
-function generateCreateApplicationCode(options) {
-  const { name, description, slug, templateId, icon, color, tags, projectId, organizationId } = options;
-  const template = templateId ? APPLICATION_TEMPLATES[templateId] : null;
-  let code = `// Create a new NetPad application
-// Using: NetPad Platform API
-
-const applicationData = {
-  name: '${name}',
-  ${description ? `description: '${description}',` : ""}
-  ${slug ? `slug: '${slug}',` : ""}
-  ${icon ? `icon: '${icon}',` : ""}
-  ${color ? `color: '${color}',` : ""}
-  ${tags && tags.length > 0 ? `tags: ${JSON.stringify(tags)},` : ""}
-  projectId: '${projectId}',
-  organizationId: '${organizationId}',
-};
-
-// API call to create application
-const response = await fetch('/api/applications', {
-  method: 'POST',
-  headers: {
-    'Content-Type': 'application/json',
-    'Authorization': \`Bearer \${process.env.NETPAD_API_KEY}\`,
-  },
-  body: JSON.stringify(applicationData),
-});
-
-const { application } = await response.json();
-console.log('Created application:', application.applicationId);
-`;
-  if (template && template.structure.forms.length > 0) {
-    code += `
-// Create forms from template: ${template.name}
-`;
-    for (const form of template.structure.forms) {
-      code += `
-// Create form: ${form.name}
-const ${form.slug.replace(/-/g, "")}FormData = {
-  name: '${form.name}',
-  slug: '${form.slug}',
-  applicationId: application.applicationId,
-  projectId: '${projectId}',
-  organizationId: '${organizationId}',
-  fieldConfigs: ${JSON.stringify(form.fields, null, 2)},
-  ${form.multiPage ? `multiPage: { enabled: true, pages: ${JSON.stringify(form.pages)} },` : ""}
-};
-
-await fetch('/api/forms', {
-  method: 'POST',
-  headers: {
-    'Content-Type': 'application/json',
-    'Authorization': \`Bearer \${process.env.NETPAD_API_KEY}\`,
-  },
-  body: JSON.stringify(${form.slug.replace(/-/g, "")}FormData),
-});
-`;
-    }
-  }
-  if (template && template.structure.workflows.length > 0) {
-    code += `
-// Create workflows from template
-`;
-    for (const workflow of template.structure.workflows) {
-      code += `
-// Workflow: ${workflow.name}
-// Trigger: ${workflow.trigger}
-// Steps: ${workflow.steps.join(" -> ")}
-// Note: Create workflow in NetPad UI or via API with full node configuration
-`;
-    }
-  }
-  return code;
-}
-function generateApplicationConfig(options) {
-  const { name, description, slug, templateId, icon, color, tags } = options;
-  const template = templateId ? APPLICATION_TEMPLATES[templateId] : null;
-  const config2 = {
-    application: {
-      name,
-      description: description || (template ? template.description : ""),
-      slug: slug || name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
-      icon,
-      color,
-      tags: tags || (template ? template.tags : []),
-      version: "1.0.0"
-    }
-  };
-  if (template) {
-    config2.template = {
-      id: template.id,
-      name: template.name,
-      category: template.category
-    };
-    config2.forms = template.structure.forms;
-    config2.workflows = template.structure.workflows;
-  }
-  return config2;
-}
 function generateApplicationContract(options) {
   const {
     applicationId,
@@ -17471,7 +17373,7 @@ var WORKFLOW_NODE_TYPES = {
         { key: "database", label: "Database", type: "string", required: true },
         { key: "collection", label: "Collection", type: "string", required: true },
         { key: "operation", label: "Operation", type: "select", options: ["find", "findOne", "aggregate"] },
-        { key: "filter", label: "Filter", type: "json" },
+        { key: "filter", label: "Filter", type: "json", aiAssist: { enabled: true, promptHint: 'e.g., "Find users created in the last 7 days"', buttonLabel: "Generate Query" } },
         { key: "projection", label: "Projection", type: "json" },
         { key: "sort", label: "Sort", type: "json" },
         { key: "limit", label: "Limit", type: "number" }
@@ -17505,7 +17407,7 @@ var WORKFLOW_NODE_TYPES = {
       inputs: [{ id: "input", label: "Input", type: "any" }],
       outputs: [{ id: "output", label: "Output", type: "any" }],
       configFields: [
-        { key: "expression", label: "Transform Expression", type: "expression", required: true }
+        { key: "expression", label: "Transform Expression", type: "expression", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Extract emails from user array" or "Add processed timestamp"', buttonLabel: "Generate Transform" } }
       ]
     },
     {
@@ -17537,9 +17439,9 @@ var WORKFLOW_NODE_TYPES = {
       inputs: [{ id: "data", label: "Template Data", type: "object" }],
       outputs: [{ id: "result", label: "Result", type: "object" }],
       configFields: [
-        { key: "to", label: "To", type: "expression", required: true },
-        { key: "subject", label: "Subject", type: "expression", required: true },
-        { key: "body", label: "Body", type: "richtext", required: true },
+        { key: "to", label: "To", type: "expression", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Send to form submitter email"', buttonLabel: "Generate Recipients" } },
+        { key: "subject", label: "Subject", type: "expression", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Create a thank you subject with user name"', buttonLabel: "Generate Subject" } },
+        { key: "body", label: "Body", type: "richtext", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Write a professional confirmation email"', buttonLabel: "Generate Body" } },
         { key: "from", label: "From", type: "string" },
         { key: "replyTo", label: "Reply To", type: "string" }
       ]
@@ -17558,10 +17460,10 @@ var WORKFLOW_NODE_TYPES = {
         { id: "status", label: "Status Code", type: "number" }
       ],
       configFields: [
-        { key: "url", label: "URL", type: "expression", required: true },
+        { key: "url", label: "URL", type: "expression", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Build Slack webhook URL with channel"', buttonLabel: "Generate URL" } },
         { key: "method", label: "Method", type: "select", options: ["GET", "POST", "PUT", "PATCH", "DELETE"] },
-        { key: "headers", label: "Headers", type: "json" },
-        { key: "body", label: "Body", type: "json" },
+        { key: "headers", label: "Headers", type: "json", aiAssist: { enabled: true, promptHint: 'e.g., "Add authorization and content-type headers"', buttonLabel: "Generate Headers" } },
+        { key: "body", label: "Body", type: "json", aiAssist: { enabled: true, promptHint: 'e.g., "Create Slack message payload from form data"', buttonLabel: "Generate Body" } },
         { key: "authentication", label: "Authentication", type: "select", options: ["none", "basic", "bearer", "api_key"] }
       ]
     },
@@ -17593,7 +17495,7 @@ var WORKFLOW_NODE_TYPES = {
       inputs: [{ id: "context", label: "Context", type: "object" }],
       outputs: [{ id: "response", label: "AI Response", type: "string" }],
       configFields: [
-        { key: "prompt", label: "Prompt", type: "richtext", required: true },
+        { key: "prompt", label: "Prompt", type: "richtext", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Write a prompt to summarize customer feedback"', buttonLabel: "Generate Prompt" } },
         { key: "model", label: "Model", type: "select", options: ["gpt-4", "gpt-3.5-turbo", "claude-3"] },
         { key: "temperature", label: "Temperature", type: "number", default: 0.7 },
         { key: "maxTokens", label: "Max Tokens", type: "number", default: 1e3 }
@@ -17613,8 +17515,26 @@ var WORKFLOW_NODE_TYPES = {
         { id: "confidence", label: "Confidence", type: "number" }
       ],
       configFields: [
-        { key: "categories", label: "Categories", type: "array", itemType: "string", required: true },
-        { key: "instructions", label: "Classification Instructions", type: "richtext" }
+        { key: "categories", label: "Categories", type: "array", itemType: "string", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Create sentiment categories" or "Support ticket priorities"', buttonLabel: "Generate Categories" } },
+        { key: "instructions", label: "Classification Instructions", type: "richtext", aiAssist: { enabled: true, promptHint: 'e.g., "Write instructions to classify support tickets by urgency"', buttonLabel: "Generate Instructions" } }
+      ]
+    }
+  ],
+  // Custom
+  custom: [
+    {
+      type: "code",
+      name: "Custom Code",
+      description: "Execute custom JavaScript code",
+      icon: "code",
+      color: "#455A64",
+      category: "custom",
+      stage: "processor",
+      inputs: [{ id: "input", label: "Input", type: "any" }],
+      outputs: [{ id: "output", label: "Output", type: "any" }],
+      configFields: [
+        { key: "code", label: "JavaScript Code", type: "code", required: true, aiAssist: { enabled: true, promptHint: 'e.g., "Calculate order total from items array"', buttonLabel: "Generate Code" } },
+        { key: "timeout", label: "Timeout (ms)", type: "number", default: 5e3 }
       ]
     }
   ]
@@ -17880,92 +17800,6 @@ var WORKFLOW_TEMPLATES = {
     ]
   }
 };
-function generateCreateWorkflowCode(options) {
-  const { name, description, templateId, applicationId, projectId, organizationId, tags } = options;
-  const template = templateId ? WORKFLOW_TEMPLATES[templateId] : null;
-  let code = `// Create a new NetPad workflow
-// Using: NetPad Platform API
-
-const workflowData = {
-  name: '${name}',
-  ${description ? `description: '${description}',` : ""}
-  projectId: '${projectId}',
-  organizationId: '${organizationId}',
-  ${applicationId ? `applicationId: '${applicationId}',` : ""}
-  ${tags && tags.length > 0 ? `tags: ${JSON.stringify(tags)},` : ""}
-`;
-  if (template) {
-    code += `
-  // Using template: ${template.name}
-  canvas: {
-    nodes: ${JSON.stringify(template.nodes, null, 4)},
-    edges: ${JSON.stringify(template.edges, null, 4)},
-    viewport: { x: 0, y: 0, zoom: 1 },
-  },
-`;
-  } else {
-    code += `
-  // Empty canvas - add nodes in the visual editor
-  canvas: {
-    nodes: [],
-    edges: [],
-    viewport: { x: 0, y: 0, zoom: 1 },
-  },
-`;
-  }
-  code += `
-  settings: {
-    executionMode: 'auto',
-    maxExecutionTime: 300000,
-    retryPolicy: {
-      maxRetries: 3,
-      backoffMultiplier: 2,
-      initialDelayMs: 1000,
-    },
-    errorHandling: 'stop',
-    timezone: 'UTC',
-  },
-  variables: [],
-};
-
-const response = await fetch('/api/workflows', {
-  method: 'POST',
-  headers: {
-    'Content-Type': 'application/json',
-    'Authorization': \`Bearer \${process.env.NETPAD_API_KEY}\`,
-  },
-  body: JSON.stringify(workflowData),
-});
-
-const { workflow } = await response.json();
-console.log('Created workflow:', workflow.id);
-`;
-  return code;
-}
-function generateWorkflowConfig(options) {
-  const { name, description, templateId, tags } = options;
-  const template = templateId ? WORKFLOW_TEMPLATES[templateId] : null;
-  return {
-    workflow: {
-      name,
-      description: description || (template ? template.description : ""),
-      tags: tags || (template ? template.tags : []),
-      status: "draft"
-    },
-    template: template ? {
-      id: template.id,
-      name: template.name,
-      category: template.category
-    } : null,
-    canvas: template ? {
-      nodes: template.nodes,
-      edges: template.edges
-    } : {
-      nodes: [],
-      edges: []
-    }
-  };
-}
 function generateAddNodeCode(workflowId, node) {
   return `// Add node to workflow
 const nodeData = ${JSON.stringify(node, null, 2)};
@@ -20097,121 +19931,852 @@ collections.forEach((coll: any) => {
 `;
 }
 
-// src/index.ts
-var server = new McpServer({
-  name: "@netpad/mcp-server",
-  version: "2.0.0"
-});
-server.resource(
-  "netpad-docs",
-  "netpad://docs/readme",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://docs/readme",
-        mimeType: "text/markdown",
-        text: DOCUMENTATION.readme
-      }
-    ]
-  })
-);
-server.resource(
-  "netpad-architecture",
-  "netpad://docs/architecture",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://docs/architecture",
-        mimeType: "text/markdown",
-        text: DOCUMENTATION.architecture
-      }
-    ]
-  })
-);
-server.resource(
-  "netpad-quick-start",
-  "netpad://docs/quick-start",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://docs/quick-start",
-        mimeType: "text/markdown",
-        text: QUICK_START_GUIDE
-      }
-    ]
-  })
-);
-server.resource(
-  "netpad-examples",
-  "netpad://docs/examples",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://docs/examples",
-        mimeType: "text/markdown",
-        text: EXAMPLES
-      }
-    ]
-  })
-);
-server.resource(
-  "netpad-field-types",
-  "netpad://reference/field-types",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://reference/field-types",
-        mimeType: "application/json",
-        text: JSON.stringify(FIELD_TYPES, null, 2)
-      }
-    ]
-  })
-);
-server.resource(
-  "netpad-operators",
-  "netpad://reference/operators",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://reference/operators",
-        mimeType: "application/json",
-        text: JSON.stringify(OPERATORS, null, 2)
-      }
-    ]
-  })
-);
-server.resource(
-  "netpad-formulas",
-  "netpad://reference/formulas",
-  async () => ({
-    contents: [
-      {
-        uri: "netpad://reference/formulas",
-        mimeType: "application/json",
-        text: JSON.stringify(FORMULA_FUNCTIONS, null, 2)
+// src/validation.ts
+import ts from "typescript";
+var INLINE_TYPES = `
+// ============================================================================
+// Types (inline - no external dependencies)
+// ============================================================================
+
+interface NetPadConfig {
+  baseUrl: string;
+  apiKey: string;
+  organizationId?: string;
+  projectId?: string;
+}
+
+interface FormFieldValidation {
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  errorMessage?: string;
+}
+
+interface FormFieldOption {
+  label: string;
+  value: string;
+}
+
+interface ConditionalLogicCondition {
+  field: string;
+  operator: string;
+  value?: string | number | boolean;
+}
+
+interface ConditionalLogic {
+  action: 'show' | 'hide';
+  logicType: 'all' | 'any';
+  conditions: ConditionalLogicCondition[];
+}
+
+interface FormField {
+  path: string;
+  label: string;
+  type: string;
+  included?: boolean;
+  required?: boolean;
+  disabled?: boolean;
+  readOnly?: boolean;
+  placeholder?: string;
+  helpText?: string;
+  options?: FormFieldOption[];
+  validation?: FormFieldValidation;
+  fieldWidth?: 'full' | 'half' | 'third' | 'quarter';
+  defaultValue?: unknown;
+  conditionalLogic?: ConditionalLogic;
+}
+
+interface FormTheme {
+  primaryColor?: string;
+  backgroundColor?: string;
+  surfaceColor?: string;
+  textColor?: string;
+  errorColor?: string;
+  successColor?: string;
+  borderRadius?: number;
+  spacing?: 'compact' | 'comfortable' | 'spacious';
+  inputStyle?: 'outlined' | 'filled' | 'standard';
+  mode?: 'light' | 'dark';
+}
+
+interface FormPage {
+  id: string;
+  title: string;
+  description?: string;
+  fields: string[];
+}
+
+interface MultiPageConfig {
+  enabled: boolean;
+  pages: FormPage[];
+  showProgressBar?: boolean;
+  showPageTitles?: boolean;
+  allowSkip?: boolean;
+  showReview?: boolean;
+}
+
+interface FormConfig {
+  name: string;
+  slug?: string;
+  description?: string;
+  fieldConfigs: FormField[];
+  submitButtonText?: string;
+  successMessage?: string;
+  theme?: FormTheme;
+  multiPage?: MultiPageConfig;
+}
+
+interface SubmitResult {
+  success: boolean;
+  submissionId?: string;
+  error?: string;
+}
+
+interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+`;
+var INLINE_WORKFLOW_TYPES = `
+interface WorkflowNode {
+  id: string;
+  type: string;
+  label: string;
+  position: { x: number; y: number };
+  config: Record<string, unknown>;
+  enabled?: boolean;
+}
+
+interface WorkflowEdge {
+  id: string;
+  source: string;
+  sourceHandle: string;
+  target: string;
+  targetHandle: string;
+  condition?: {
+    expression: string;
+    label?: string;
+  };
+}
+
+interface WorkflowSettings {
+  executionMode?: 'auto' | 'manual';
+  maxExecutionTime?: number;
+  retryPolicy?: {
+    maxRetries: number;
+    backoffMultiplier: number;
+    initialDelayMs: number;
+  };
+}
+
+interface WorkflowConfig {
+  name: string;
+  description?: string;
+  tags?: string[];
+  nodes: WorkflowNode[];
+  edges: WorkflowEdge[];
+  settings?: WorkflowSettings;
+}
+
+interface CreateWorkflowResult {
+  success: boolean;
+  workflowId?: string;
+  error?: string;
+}
+`;
+var SKIPPED_ERROR_PATTERNS = [
+  "Cannot find module",
+  // Global types (not available in isolated compilation)
+  "Cannot find global type",
+  "Cannot find name 'Array'",
+  "Cannot find name 'String'",
+  "Cannot find name 'Number'",
+  "Cannot find name 'Boolean'",
+  "Cannot find name 'Object'",
+  "Cannot find name 'Function'",
+  "Cannot find name 'Symbol'",
+  "Cannot find name 'Error'",
+  "Cannot find name 'Promise'",
+  "Cannot find name 'Record'",
+  "Cannot find name 'Partial'",
+  "Cannot find name 'Required'",
+  "Cannot find name 'Readonly'",
+  "Cannot find name 'Pick'",
+  "Cannot find name 'Omit'",
+  "Cannot find name 'Exclude'",
+  "Cannot find name 'Extract'",
+  "Cannot find name 'Map'",
+  "Cannot find name 'Set'",
+  "Cannot find name 'WeakMap'",
+  "Cannot find name 'WeakSet'",
+  "Cannot find name 'JSON'",
+  "Cannot find name 'Date'",
+  "Cannot find name 'RegExp'",
+  "Cannot find name 'Math'",
+  // Runtime globals
+  "Cannot find name 'process'",
+  "Cannot find name 'fetch'",
+  "Cannot find name 'console'",
+  "Cannot find name 'RequestInit'",
+  "Cannot find name 'Response'",
+  "Cannot find name 'Headers'",
+  "Cannot find name 'URL'",
+  "Cannot find name 'URLSearchParams'",
+  "Cannot find name 'FormData'",
+  "Cannot find name 'Blob'",
+  "Cannot find name 'File'",
+  "Cannot find name 'AbortController'",
+  "Cannot find name 'AbortSignal'",
+  "Cannot find name 'setTimeout'",
+  "Cannot find name 'clearTimeout'",
+  "Cannot find name 'setInterval'",
+  "Cannot find name 'clearInterval'",
+  // React-specific
+  "Cannot find name 'React'",
+  "Cannot find namespace 'React'",
+  "Cannot find name 'JSX'",
+  // Node.js specific
+  "Cannot find name 'Buffer'",
+  "Cannot find name '__dirname'",
+  "Cannot find name '__filename'",
+  "Cannot find name 'require'",
+  "Cannot find name 'module'",
+  "Cannot find name 'exports'",
+  // DOM types
+  "Cannot find name 'document'",
+  "Cannot find name 'window'",
+  "Cannot find name 'HTMLElement'",
+  "Cannot find name 'Event'",
+  "Cannot find name 'EventTarget'",
+  // Library suggestions
+  "Do you need to change your target library",
+  // Strict mode catch clause errors (handled by instanceof checks at runtime)
+  "is of type 'unknown'"
+];
+function validateTypeScript(code) {
+  const result = validateTypeScriptDetailed(code);
+  return result.errors.map(
+    (e) => e.line ? `Line ${e.line}:${e.column}: ${e.message}` : e.message
+  );
+}
+function validateTypeScriptDetailed(code) {
+  const errors = [];
+  const warnings = [];
+  const sourceFile = ts.createSourceFile(
+    "generated.ts",
+    code,
+    ts.ScriptTarget.ES2020,
+    true,
+    ts.ScriptKind.TS
+  );
+  const compilerOptions = {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    noEmit: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    // Don't require external type definitions
+    types: [],
+    lib: ["ES2020", "DOM"],
+    // JSX support for React components
+    jsx: ts.JsxEmit.React,
+    jsxFactory: "React.createElement",
+    jsxFragmentFactory: "React.Fragment"
+  };
+  const defaultCompilerHost = ts.createCompilerHost(compilerOptions);
+  const customCompilerHost = {
+    ...defaultCompilerHost,
+    getSourceFile: (fileName, languageVersion) => {
+      if (fileName === "generated.ts") {
+        return sourceFile;
+      }
+      if (fileName.endsWith(".ts") || fileName.endsWith(".tsx")) {
+        return ts.createSourceFile(
+          fileName,
+          "",
+          languageVersion,
+          true
+        );
+      }
+      return defaultCompilerHost.getSourceFile(fileName, languageVersion);
+    },
+    fileExists: (fileName) => {
+      if (fileName === "generated.ts") return true;
+      return defaultCompilerHost.fileExists(fileName);
+    },
+    readFile: (fileName) => {
+      if (fileName === "generated.ts") return code;
+      return defaultCompilerHost.readFile(fileName);
+    }
+  };
+  const program = ts.createProgram(
+    ["generated.ts"],
+    compilerOptions,
+    customCompilerHost
+  );
+  const allDiagnostics = ts.getPreEmitDiagnostics(program);
+  for (const diagnostic of allDiagnostics) {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    const shouldSkip = SKIPPED_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+    if (shouldSkip) {
+      continue;
+    }
+    if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+      warnings.push(message);
+      continue;
+    }
+    if (diagnostic.category === ts.DiagnosticCategory.Error) {
+      const error48 = {
+        message,
+        code: diagnostic.code,
+        fixable: isFixableError(diagnostic.code, message),
+        fixSuggestion: getFixSuggestion(diagnostic.code, message)
+      };
+      if (diagnostic.file && diagnostic.start !== void 0) {
+        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        error48.line = line + 1;
+        error48.column = character + 1;
       }
-    ]
-  })
-);
+      errors.push(error48);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    fixable: errors.some((e) => e.fixable)
+  };
+}
+function isFixableError(code, message) {
+  if (code === 1005) return true;
+  if (code === 7006) return true;
+  if (code === 1064) return true;
+  if (code === 2304 && message.includes("Cannot find name")) return false;
+  if (code === 2345) return false;
+  if (code === 2339) return false;
+  return false;
+}
+function getFixSuggestion(code, message) {
+  if (code === 1005) {
+    return "Add missing semicolon";
+  }
+  if (code === 7006) {
+    return "Add type annotation to parameter (e.g., ': unknown' or ': string')";
+  }
+  if (code === 1064) {
+    return "Add Promise return type to async function";
+  }
+  if (code === 2304) {
+    const match = message.match(/Cannot find name '(\w+)'/);
+    if (match) {
+      return `Ensure '${match[1]}' is defined or imported`;
+    }
+  }
+  if (code === 2345) {
+    return "Check that the argument type matches the expected parameter type";
+  }
+  if (code === 2339) {
+    const match = message.match(/Property '(\w+)' does not exist/);
+    if (match) {
+      return `Add '${match[1]}' property to the type definition or use type assertion`;
+    }
+  }
+  return void 0;
+}
+function attemptAutoFix(code, _errors) {
+  let fixedCode = code;
+  const result = validateTypeScriptDetailed(code);
+  for (const error48 of result.errors) {
+    if (!error48.fixable) continue;
+    if (error48.code === 1005 && error48.message.includes("';' expected")) {
+      fixedCode = fixedCode.replace(
+        /(\})\s*(\n\s*(?:const|let|var|function|export|import|class|interface|type|async|if|for|while|switch|try))/g,
+        "$1;\n$2"
+      );
+      fixedCode = fixedCode.replace(
+        /(\s=\s[^;{]+)\s*(\n\s*(?:const|let|var|function|export|import|class|interface|type|async))/g,
+        "$1;$2"
+      );
+    }
+    if (error48.code === 7006 && error48.message.includes("implicitly has an")) {
+      fixedCode = fixedCode.replace(
+        /\(([a-zA-Z_][a-zA-Z0-9_]*)\s*\)/g,
+        "($1: unknown)"
+      );
+      fixedCode = fixedCode.replace(
+        /\(([a-zA-Z_][a-zA-Z0-9_]*)\s*,\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)/g,
+        "($1: unknown, $2: unknown)"
+      );
+    }
+    if (error48.code === 1064) {
+      fixedCode = fixedCode.replace(
+        /async function (\w+)\(([^)]*)\)\s*\{/g,
+        (match, name, params) => {
+          if (match.includes(":")) return match;
+          return `async function ${name}(${params}): Promise<unknown> {`;
+        }
+      );
+      fixedCode = fixedCode.replace(
+        /const (\w+) = async \(([^)]*)\)\s*=>/g,
+        (match, name, params) => {
+          if (match.includes(":")) return match;
+          return `const ${name} = async (${params}): Promise<unknown> =>`;
+        }
+      );
+    }
+  }
+  fixedCode = fixedCode.replace(/,(\s*[}\]])/g, "$1");
+  fixedCode = fixedCode.replace(
+    /export \{ ([^}]+) \}(\s*\n)/g,
+    "export { $1 };$2"
+  );
+  return fixedCode;
+}
+function attemptAutoFixIterative(code, maxIterations = 3) {
+  let currentCode = code;
+  let iterations = 0;
+  let previousErrorCount = Infinity;
+  while (iterations < maxIterations) {
+    const errors = validateTypeScript(currentCode);
+    if (errors.length === 0 || errors.length >= previousErrorCount) {
+      return {
+        code: currentCode,
+        fixed: errors.length === 0,
+        iterations,
+        remainingErrors: errors
+      };
+    }
+    previousErrorCount = errors.length;
+    currentCode = attemptAutoFix(currentCode, errors);
+    iterations++;
+  }
+  const finalErrors = validateTypeScript(currentCode);
+  return {
+    code: currentCode,
+    fixed: finalErrors.length === 0,
+    iterations,
+    remainingErrors: finalErrors
+  };
+}
+function getSyntaxErrors(code) {
+  const sourceFile = ts.createSourceFile(
+    "check.ts",
+    code,
+    ts.ScriptTarget.ES2020,
+    true,
+    ts.ScriptKind.TS
+  );
+  const syntaxErrors = sourceFile.parseDiagnostics || [];
+  return syntaxErrors.map((diagnostic) => {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    if (diagnostic.start !== void 0) {
+      const { line, character } = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+      return `Line ${line + 1}:${character + 1}: ${message}`;
+    }
+    return message;
+  });
+}
+var STANDARD_ENV_VARS = [
+  {
+    name: "NETPAD_URL",
+    description: "NetPad API URL",
+    example: "https://api.netpad.io"
+  },
+  {
+    name: "NETPAD_API_KEY",
+    description: "Your NetPad API key",
+    example: "np_live_xxxxx"
+  },
+  {
+    name: "NETPAD_ORG_ID",
+    description: "Your organization ID",
+    example: "org_xxxxx"
+  },
+  {
+    name: "NETPAD_PROJECT_ID",
+    description: "Your project ID",
+    example: "proj_xxxxx"
+  }
+];
+function generateSelfContainedCode(options) {
+  const {
+    title,
+    description,
+    includeFormTypes = true,
+    includeWorkflowTypes = false,
+    configCode,
+    functionsCode,
+    mainCode
+  } = options;
+  let code = `/**
+ * ${title}
+ * ${description || "Generated by NetPad"}
+ *
+ * Run with: npx tsx ${title.toLowerCase().replace(/\s+/g, "-")}.ts
+ */
+
+`;
+  if (includeFormTypes) {
+    code += INLINE_TYPES + "\n";
+  }
+  if (includeWorkflowTypes) {
+    code += INLINE_WORKFLOW_TYPES + "\n";
+  }
+  code += `// ============================================================================
+// Configuration
+// ============================================================================
+
+const CONFIG = {
+  baseUrl: process.env.NETPAD_URL ?? 'https://api.netpad.io',
+  apiKey: process.env.NETPAD_API_KEY ?? '',
+  organizationId: process.env.NETPAD_ORG_ID ?? '',
+  projectId: process.env.NETPAD_PROJECT_ID ?? '',
+};
+
+${configCode}
+
+// ============================================================================
+// API Functions
+// ============================================================================
+
+${functionsCode}
+`;
+  if (mainCode) {
+    code += `
+// ============================================================================
+// Main
+// ============================================================================
+
+${mainCode}
+`;
+  }
+  return code;
+}
+function createToolOutput(options) {
+  const { code, filename, additionalFiles, envVars, dependencies, skipValidation } = options;
+  if (skipValidation) {
+    return {
+      code,
+      filename,
+      additionalFiles,
+      envVars: envVars || STANDARD_ENV_VARS,
+      dependencies,
+      validated: true
+      // Assumed valid
+    };
+  }
+  const syntaxErrors = getSyntaxErrors(code);
+  if (syntaxErrors.length > 0) {
+    return {
+      code,
+      filename,
+      additionalFiles,
+      envVars: envVars || STANDARD_ENV_VARS,
+      dependencies,
+      validated: false,
+      validationErrors: syntaxErrors
+    };
+  }
+  const fixResult = attemptAutoFixIterative(code);
+  return {
+    code: fixResult.code,
+    filename,
+    additionalFiles,
+    envVars: envVars || STANDARD_ENV_VARS,
+    dependencies,
+    validated: fixResult.fixed,
+    validationErrors: fixResult.remainingErrors.length > 0 ? fixResult.remainingErrors : void 0
+  };
+}
+function formatToolOutput(output) {
+  let result = "";
+  if (output.validated) {
+    result += "\u2705 **Code validated successfully** - Ready to use!\n\n";
+  } else {
+    result += "\u26A0\uFE0F **Code validation warnings:**\n\n";
+    result += "The generated code has some issues that may need manual review:\n\n";
+    for (const error48 of output.validationErrors || []) {
+      result += `- ${error48}
+`;
+    }
+    result += "\n> Note: The code may still work in most environments. These warnings are from strict TypeScript checking.\n\n";
+  }
+  result += "## Quick Start\n\n";
+  result += "```bash\n";
+  result += `# Save the code below to ${output.filename}
+`;
+  result += `# Then run:
+`;
+  result += `npx tsx ${output.filename}
+`;
+  result += "```\n\n";
+  if (output.envVars.length > 0) {
+    result += "## Required Environment Variables\n\n";
+    result += "Create a `.env` file or export these variables:\n\n";
+    result += "```bash\n";
+    for (const env of output.envVars) {
+      result += `# ${env.description}
+`;
+      result += `export ${env.name}="${env.example}"
+`;
+    }
+    result += "```\n\n";
+  }
+  if (output.dependencies && output.dependencies.length > 0) {
+    result += "## Dependencies\n\n";
+    result += "```bash\n";
+    result += `npm install ${output.dependencies.join(" ")}
+`;
+    result += "```\n\n";
+  }
+  result += `## ${output.filename}
+
+`;
+  result += "```typescript\n";
+  result += output.code;
+  result += "\n```\n";
+  if (output.additionalFiles && output.additionalFiles.length > 0) {
+    result += "\n## Additional Files\n";
+    for (const file2 of output.additionalFiles) {
+      result += `
+### ${file2.filename}
+
+`;
+      result += "```typescript\n";
+      result += file2.code;
+      result += "\n```\n";
+    }
+  }
+  return result;
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "@netpad/mcp-server",
+  version: "2.0.0"
+});
+server.resource(
+  "netpad-docs",
+  "netpad://docs/readme",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://docs/readme",
+        mimeType: "text/markdown",
+        text: DOCUMENTATION.readme
+      }
+    ]
+  })
+);
+server.resource(
+  "netpad-architecture",
+  "netpad://docs/architecture",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://docs/architecture",
+        mimeType: "text/markdown",
+        text: DOCUMENTATION.architecture
+      }
+    ]
+  })
+);
+server.resource(
+  "netpad-quick-start",
+  "netpad://docs/quick-start",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://docs/quick-start",
+        mimeType: "text/markdown",
+        text: QUICK_START_GUIDE
+      }
+    ]
+  })
+);
+server.resource(
+  "netpad-examples",
+  "netpad://docs/examples",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://docs/examples",
+        mimeType: "text/markdown",
+        text: EXAMPLES
+      }
+    ]
+  })
+);
+server.resource(
+  "netpad-field-types",
+  "netpad://reference/field-types",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://reference/field-types",
+        mimeType: "application/json",
+        text: JSON.stringify(FIELD_TYPES, null, 2)
+      }
+    ]
+  })
+);
+server.resource(
+  "netpad-operators",
+  "netpad://reference/operators",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://reference/operators",
+        mimeType: "application/json",
+        text: JSON.stringify(OPERATORS, null, 2)
+      }
+    ]
+  })
+);
+server.resource(
+  "netpad-formulas",
+  "netpad://reference/formulas",
+  async () => ({
+    contents: [
+      {
+        uri: "netpad://reference/formulas",
+        mimeType: "application/json",
+        text: JSON.stringify(FORMULA_FUNCTIONS, null, 2)
+      }
+    ]
+  })
+);
 server.tool(
   "generate_form",
-  "Generate a complete NetPad form configuration from a description. Provide a natural language description of the form you want to create, and this tool will generate the full FormConfiguration object.",
+  "Generate a complete NetPad form configuration from a description. Returns validated TypeScript code by default (can optionally return JSON). The TypeScript output includes inline types, form config, and API functions - ready to run with `npx tsx`.",
   {
     description: external_exports.string().describe("Natural language description of the form to generate"),
     formName: external_exports.string().describe("Name of the form"),
     includeMultiPage: external_exports.boolean().optional().describe("Whether to organize fields into multiple pages"),
-    includeTheme: external_exports.boolean().optional().describe("Whether to include theme configuration")
+    includeTheme: external_exports.boolean().optional().describe("Whether to include theme configuration"),
+    outputFormat: external_exports.enum(["typescript", "json"]).optional().describe('Output format: "typescript" (default) for complete working code, "json" for raw config')
   },
-  async ({ description, formName, includeMultiPage, includeTheme }) => {
+  async ({ description, formName, includeMultiPage, includeTheme, outputFormat = "typescript" }) => {
     const schema = generateFormSchema(description, formName, {
       multiPage: includeMultiPage,
       theme: includeTheme
     });
+    if (outputFormat === "json") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(schema, null, 2)
+          }
+        ]
+      };
+    }
+    const slug = formName.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    const configCode = `export const formConfig: FormConfig = ${JSON.stringify({
+      ...schema,
+      slug
+    }, null, 2)};`;
+    const functionsCode = `/**
+ * Submit form data to the NetPad API.
+ */
+export async function submitForm(data: Record<string, unknown>): Promise<SubmitResult> {
+  try {
+    const response = await fetch(
+      \`\${CONFIG.baseUrl}/api/forms/\${formConfig.slug}/submit\`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+        },
+        body: JSON.stringify({ data }),
+      }
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      return { success: false, error };
+    }
+
+    const result = await response.json() as { submissionId: string };
+    return { success: true, submissionId: result.submissionId };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
+
+/**
+ * Create the form in NetPad (run once to set up).
+ */
+export async function createForm(): Promise<{ formId: string } | { error: string }> {
+  try {
+    const response = await fetch(\`\${CONFIG.baseUrl}/api/forms\`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+      },
+      body: JSON.stringify({
+        ...formConfig,
+        organizationId: CONFIG.organizationId,
+        projectId: CONFIG.projectId,
+      }),
+    });
+
+    if (!response.ok) {
+      return { error: await response.text() };
+    }
+
+    const result = await response.json() as { form: { formId: string } };
+    return { formId: result.form.formId };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : 'Unknown error' };
+  }
+}`;
+    const mainCode = `// Example usage
+async function main() {
+  console.log('Creating form:', formConfig.name);
+
+  // Create the form (run once)
+  const createResult = await createForm();
+  if ('error' in createResult) {
+    console.error('Failed to create form:', createResult.error);
+    return;
+  }
+
+  console.log('\u2705 Form created with ID:', createResult.formId);
+  console.log('Form slug:', formConfig.slug);
+}
+
+// Uncomment to run:
+// main().catch(console.error);
+`;
+    const code = generateSelfContainedCode({
+      title: formName,
+      description: schema.description,
+      includeFormTypes: true,
+      configCode,
+      functionsCode,
+      mainCode
+    });
+    const output = createToolOutput({
+      code,
+      filename: `${slug}.ts`,
+      envVars: STANDARD_ENV_VARS
+    });
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(schema, null, 2)
+          text: formatToolOutput(output)
         }
       ]
     };
@@ -20363,9 +20928,440 @@ server.tool(
     }
   }
 );
+server.tool(
+  "get_reference",
+  "Get NetPad reference information: field types, operators, formula functions, validation options, theme options, or documentation. This is the recommended way to access all reference data.",
+  {
+    type: external_exports.enum([
+      "field_types",
+      "operators",
+      "formula_functions",
+      "validation_options",
+      "theme_options",
+      "documentation"
+    ]).describe("The type of reference to retrieve"),
+    category: external_exports.string().optional().describe('Filter by category (for field_types: "text", "selection", "date"; for formula_functions: "math", "string", "date")'),
+    topic: external_exports.enum(["readme", "architecture", "quick-start", "examples", "api-client"]).optional().describe('Documentation topic (required when type is "documentation")')
+  },
+  async ({ type, category, topic }) => {
+    switch (type) {
+      case "field_types": {
+        let types = FIELD_TYPES;
+        if (category) {
+          types = types.filter((t) => t.category.toLowerCase() === category.toLowerCase());
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              referenceType: "field_types",
+              count: types.length,
+              categories: [...new Set(FIELD_TYPES.map((t) => t.category))],
+              data: types
+            }, null, 2)
+          }]
+        };
+      }
+      case "operators": {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              referenceType: "operators",
+              count: OPERATORS.length,
+              data: OPERATORS
+            }, null, 2)
+          }]
+        };
+      }
+      case "formula_functions": {
+        let functions = FORMULA_FUNCTIONS;
+        if (category) {
+          functions = functions.filter((f) => f.category.toLowerCase() === category.toLowerCase());
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              referenceType: "formula_functions",
+              count: functions.length,
+              categories: [...new Set(FORMULA_FUNCTIONS.map((f) => f.category))],
+              data: functions
+            }, null, 2)
+          }]
+        };
+      }
+      case "validation_options": {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              referenceType: "validation_options",
+              data: VALIDATION_OPTIONS
+            }, null, 2)
+          }]
+        };
+      }
+      case "theme_options": {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              referenceType: "theme_options",
+              data: THEME_OPTIONS
+            }, null, 2)
+          }]
+        };
+      }
+      case "documentation": {
+        const docs = {
+          "readme": DOCUMENTATION.readme,
+          "architecture": ARCHITECTURE_GUIDE,
+          "quick-start": QUICK_START_GUIDE,
+          "examples": EXAMPLES,
+          "api-client": DOCUMENTATION.apiClient
+        };
+        const selectedTopic = topic || "readme";
+        return {
+          content: [{
+            type: "text",
+            text: `# NetPad Documentation: ${selectedTopic}
+
+${docs[selectedTopic] || "Documentation not found"}
+
+---
+Available topics: ${Object.keys(docs).join(", ")}`
+          }]
+        };
+      }
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: "Invalid reference type. Use: field_types, operators, formula_functions, validation_options, theme_options, or documentation"
+          }]
+        };
+    }
+  }
+);
+server.tool(
+  "browse_templates",
+  "Browse all NetPad templates: forms (25+), applications (7), workflows (5), conversational (4), and query templates. This is the recommended way to discover and access all templates.",
+  {
+    templateType: external_exports.enum([
+      "form",
+      "application",
+      "workflow",
+      "conversational",
+      "query",
+      "use_case",
+      "all"
+    ]).describe("Type of templates to browse"),
+    action: external_exports.enum(["list", "get", "categories"]).optional().describe('Action: "list" (default) returns summaries, "get" returns full details, "categories" lists available categories'),
+    templateId: external_exports.string().optional().describe('Template ID (required when action is "get")'),
+    category: external_exports.string().optional().describe("Filter templates by category"),
+    search: external_exports.string().optional().describe("Search templates by name, description, or tags (form templates only)")
+  },
+  async ({ templateType, action = "list", templateId, category, search }) => {
+    const formatSummary = (id, name, desc, cat, extra = {}) => ({
+      id,
+      name,
+      description: desc,
+      category: cat,
+      ...extra
+    });
+    switch (templateType) {
+      case "form": {
+        if (action === "categories") {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                templateType: "form",
+                categories: TEMPLATE_CATEGORIES,
+                totalTemplates: Object.keys(FORM_TEMPLATES).length
+              }, null, 2)
+            }]
+          };
+        }
+        if (action === "get" && templateId) {
+          const template = getTemplateById(templateId);
+          if (!template) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Form template "${templateId}" not found`,
+                  availableTemplates: Object.keys(FORM_TEMPLATES)
+                }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+        }
+        let templates;
+        if (search) {
+          templates = searchTemplates(search);
+        } else if (category) {
+          templates = getTemplatesByCategory(category);
+        } else {
+          templates = Object.values(FORM_TEMPLATES);
+        }
+        const summary = templates.map((t) => formatSummary(t.id, t.name, t.description, t.category, {
+          tags: t.tags,
+          icon: t.icon,
+          fieldCount: t.fields.length,
+          hasMultiPage: !!t.multiPage?.enabled
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              templateType: "form",
+              templates: summary,
+              total: summary.length,
+              categories: [...new Set(templates.map((t) => t.category))]
+            }, null, 2)
+          }]
+        };
+      }
+      case "application": {
+        if (action === "categories") {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                templateType: "application",
+                categories: [...new Set(Object.values(APPLICATION_TEMPLATES).map((t) => t.category))],
+                totalTemplates: Object.keys(APPLICATION_TEMPLATES).length
+              }, null, 2)
+            }]
+          };
+        }
+        if (action === "get" && templateId) {
+          const template = APPLICATION_TEMPLATES[templateId];
+          if (!template) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Application template "${templateId}" not found`,
+                  availableTemplates: Object.keys(APPLICATION_TEMPLATES)
+                }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+        }
+        let templates = Object.values(APPLICATION_TEMPLATES);
+        if (category) {
+          templates = templates.filter((t) => t.category.toLowerCase() === category.toLowerCase());
+        }
+        const summary = templates.map((t) => formatSummary(t.id, t.name, t.description, t.category, {
+          tags: t.tags,
+          formsCount: t.structure.forms.length,
+          workflowsCount: t.structure.workflows.length
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              templateType: "application",
+              templates: summary,
+              total: summary.length,
+              categories: [...new Set(Object.values(APPLICATION_TEMPLATES).map((t) => t.category))]
+            }, null, 2)
+          }]
+        };
+      }
+      case "workflow": {
+        if (action === "categories") {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                templateType: "workflow",
+                categories: [...new Set(Object.values(WORKFLOW_TEMPLATES).map((t) => t.category))],
+                totalTemplates: Object.keys(WORKFLOW_TEMPLATES).length
+              }, null, 2)
+            }]
+          };
+        }
+        if (action === "get" && templateId) {
+          const template = WORKFLOW_TEMPLATES[templateId];
+          if (!template) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Workflow template "${templateId}" not found`,
+                  availableTemplates: Object.keys(WORKFLOW_TEMPLATES)
+                }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+        }
+        let templates = Object.values(WORKFLOW_TEMPLATES);
+        if (category) {
+          templates = templates.filter((t) => t.category.toLowerCase() === category.toLowerCase());
+        }
+        const summary = templates.map((t) => formatSummary(t.id, t.name, t.description, t.category, {
+          tags: t.tags,
+          nodesCount: t.nodes.length,
+          edgesCount: t.edges.length
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              templateType: "workflow",
+              templates: summary,
+              total: summary.length,
+              categories: [...new Set(Object.values(WORKFLOW_TEMPLATES).map((t) => t.category))]
+            }, null, 2)
+          }]
+        };
+      }
+      case "conversational": {
+        if (action === "categories") {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                templateType: "conversational",
+                categories: [...new Set(Object.values(CONVERSATIONAL_TEMPLATES).map((t) => t.category))],
+                totalTemplates: Object.keys(CONVERSATIONAL_TEMPLATES).length
+              }, null, 2)
+            }]
+          };
+        }
+        if (action === "get" && templateId) {
+          const template = CONVERSATIONAL_TEMPLATES[templateId];
+          if (!template) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Conversational template "${templateId}" not found`,
+                  availableTemplates: Object.keys(CONVERSATIONAL_TEMPLATES)
+                }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+        }
+        let templates = Object.values(CONVERSATIONAL_TEMPLATES);
+        if (category) {
+          templates = templates.filter((t) => t.category.toLowerCase() === category.toLowerCase());
+        }
+        const summary = templates.map((t) => formatSummary(t.id, t.name, t.description, t.category, {
+          tags: t.tags,
+          topicsCount: t.defaultConfig.topics.length,
+          extractionFieldsCount: t.defaultConfig.extractionSchema.length
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              templateType: "conversational",
+              templates: summary,
+              total: summary.length,
+              categories: [...new Set(Object.values(CONVERSATIONAL_TEMPLATES).map((t) => t.category))]
+            }, null, 2)
+          }]
+        };
+      }
+      case "query": {
+        if (action === "get" && templateId) {
+          const template = getQueryTemplate(templateId);
+          if (!template) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Query template "${templateId}" not found`,
+                  availableTemplates: listQueryTemplates()
+                }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+        }
+        const templates = listQueryTemplates();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              templateType: "query",
+              templates,
+              total: templates.length
+            }, null, 2)
+          }]
+        };
+      }
+      case "use_case": {
+        if (action === "get" && templateId) {
+          const template = USE_CASE_TEMPLATES[templateId];
+          if (!template) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Use case template "${templateId}" not found`,
+                  availableTemplates: Object.keys(USE_CASE_TEMPLATES)
+                }, null, 2)
+              }]
+            };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+        }
+        const useCaseIds = Object.keys(USE_CASE_TEMPLATES);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              templateType: "use_case",
+              templates: useCaseIds,
+              total: useCaseIds.length,
+              note: 'Use action="get" with templateId to retrieve full template details'
+            }, null, 2)
+          }]
+        };
+      }
+      case "all": {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              overview: "NetPad Template Catalog",
+              templateTypes: [
+                { type: "form", count: Object.keys(FORM_TEMPLATES).length, categories: TEMPLATE_CATEGORIES.length, description: "Pre-built form configurations with fields, validation, and styling" },
+                { type: "application", count: Object.keys(APPLICATION_TEMPLATES).length, description: "Complete applications with forms, workflows, and settings" },
+                { type: "workflow", count: Object.keys(WORKFLOW_TEMPLATES).length, description: "Automated workflow patterns with triggers, conditions, and actions" },
+                { type: "conversational", count: Object.keys(CONVERSATIONAL_TEMPLATES).length, description: "AI-powered conversational form templates" },
+                { type: "query", count: listQueryTemplates().length, description: "MongoDB query patterns for common operations" },
+                { type: "use_case", count: Object.keys(USE_CASE_TEMPLATES).length, description: "Industry use case blueprints" }
+              ],
+              totalTemplates: Object.keys(FORM_TEMPLATES).length + Object.keys(APPLICATION_TEMPLATES).length + Object.keys(WORKFLOW_TEMPLATES).length + Object.keys(CONVERSATIONAL_TEMPLATES).length + listQueryTemplates().length + Object.keys(USE_CASE_TEMPLATES).length,
+              usage: 'Use templateType to filter, action="get" with templateId to get details, or action="categories" to see available categories'
+            }, null, 2)
+          }]
+        };
+      }
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: "Invalid templateType. Use: form, application, workflow, conversational, query, use_case, or all"
+          }]
+        };
+    }
+  }
+);
 server.tool(
   "list_field_types",
-  "List all supported field types in @netpad/forms with their descriptions and usage.",
+  '[DEPRECATED - use get_reference with type="field_types" instead] List all supported field types in @netpad/forms with their descriptions and usage.',
   {
     category: external_exports.string().optional().describe('Filter by category (e.g., "text", "selection", "date")')
   },
@@ -20378,7 +21374,9 @@ server.tool(
       content: [
         {
           type: "text",
-          text: JSON.stringify(types, null, 2)
+          text: `DEPRECATED: This tool is deprecated. Use get_reference with type="field_types" instead.
+
+${JSON.stringify(types, null, 2)}`
         }
       ]
     };
@@ -20386,14 +21384,16 @@ server.tool(
 );
 server.tool(
   "list_operators",
-  "List all available conditional logic operators with descriptions.",
+  '[DEPRECATED - use get_reference with type="operators" instead] List all available conditional logic operators with descriptions.',
   {},
   async () => {
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(OPERATORS, null, 2)
+          text: `DEPRECATED: This tool is deprecated. Use get_reference with type="operators" instead.
+
+${JSON.stringify(OPERATORS, null, 2)}`
         }
       ]
     };
@@ -20401,7 +21401,7 @@ server.tool(
 );
 server.tool(
   "list_formula_functions",
-  "List all available formula functions for computed fields.",
+  '[DEPRECATED - use get_reference with type="formula_functions" instead] List all available formula functions for computed fields.',
   {
     category: external_exports.string().optional().describe('Filter by category (e.g., "math", "string", "date")')
   },
@@ -20414,7 +21414,9 @@ server.tool(
       content: [
         {
           type: "text",
-          text: JSON.stringify(functions, null, 2)
+          text: `DEPRECATED: This tool is deprecated. Use get_reference with type="formula_functions" instead.
+
+${JSON.stringify(functions, null, 2)}`
         }
       ]
     };
@@ -20422,14 +21424,16 @@ server.tool(
 );
 server.tool(
   "list_validation_options",
-  "List all available validation options for form fields.",
+  '[DEPRECATED - use get_reference with type="validation_options" instead] List all available validation options for form fields.',
   {},
   async () => {
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(VALIDATION_OPTIONS, null, 2)
+          text: `DEPRECATED: This tool is deprecated. Use get_reference with type="validation_options" instead.
+
+${JSON.stringify(VALIDATION_OPTIONS, null, 2)}`
         }
       ]
     };
@@ -20437,14 +21441,16 @@ server.tool(
 );
 server.tool(
   "list_theme_options",
-  "List all available theme customization options.",
+  '[DEPRECATED - use get_reference with type="theme_options" instead] List all available theme customization options.',
   {},
   async () => {
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(THEME_OPTIONS, null, 2)
+          text: `DEPRECATED: This tool is deprecated. Use get_reference with type="theme_options" instead.
+
+${JSON.stringify(THEME_OPTIONS, null, 2)}`
         }
       ]
     };
@@ -20452,7 +21458,7 @@ server.tool(
 );
 server.tool(
   "get_documentation",
-  "Get NetPad forms documentation. Use this to learn about features, APIs, and best practices.",
+  '[DEPRECATED - use get_reference with type="documentation" instead] Get NetPad forms documentation. Use this to learn about features, APIs, and best practices.',
   {
     topic: external_exports.enum(["readme", "architecture", "quick-start", "examples", "api-client"]).describe("The documentation topic to retrieve")
   },
@@ -20468,7 +21474,9 @@ server.tool(
       content: [
         {
           type: "text",
-          text: docs[topic] || "Documentation not found"
+          text: `DEPRECATED: This tool is deprecated. Use get_reference with type="documentation" and topic="${topic}" instead.
+
+${docs[topic] || "Documentation not found"}`
         }
       ]
     };
@@ -20476,73 +21484,404 @@ server.tool(
 );
 server.tool(
   "generate_react_code",
-  "Generate React component code that uses @netpad/forms to render a form.",
+  "Generate a complete, self-contained React component with inline types and fetch-based API calls. No external @netpad/* imports required - ready to copy-paste and use.",
   {
     formConfig: external_exports.string().describe("The form configuration JSON"),
     componentName: external_exports.string().optional().describe("Name of the React component"),
     includeSubmitHandler: external_exports.boolean().optional().describe("Whether to include a submit handler"),
-    useNetPadClient: external_exports.boolean().optional().describe("Whether to use NetPad API client for submission")
+    includeApiSubmission: external_exports.boolean().optional().describe("Whether to submit to NetPad API via fetch (default: true)")
   },
-  async ({ formConfig, componentName = "MyForm", includeSubmitHandler = true, useNetPadClient = false }) => {
-    let code = `import { FormRenderer } from '@netpad/forms';
-`;
-    if (useNetPadClient) {
-      code += `import { createNetPadClient } from '@netpad/forms';
-`;
+  async ({ formConfig, componentName = "MyForm", includeSubmitHandler = true, includeApiSubmission = true }) => {
+    let parsedConfig;
+    try {
+      parsedConfig = JSON.parse(formConfig);
+    } catch {
+      parsedConfig = { name: componentName, slug: componentName.toLowerCase().replace(/\s+/g, "-") };
+    }
+    const formSlug = parsedConfig.slug || parsedConfig.name?.toLowerCase().replace(/\s+/g, "-") || "form";
+    const code = `/**
+ * ${componentName} - React Form Component
+ * Generated by NetPad
+ *
+ * This is a self-contained component with inline types.
+ * No @netpad/* imports required.
+ */
+
+'use client';
+
+import React, { useState, FormEvent, ChangeEvent } from 'react';
+
+// ============================================================================
+// Types (inline - no external dependencies)
+// ============================================================================
+
+interface FormFieldOption {
+  label: string;
+  value: string;
+}
+
+interface FormFieldValidation {
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  errorMessage?: string;
+}
+
+interface FormField {
+  path: string;
+  label: string;
+  type: string;
+  included?: boolean;
+  required?: boolean;
+  placeholder?: string;
+  helpText?: string;
+  options?: FormFieldOption[];
+  validation?: FormFieldValidation;
+  fieldWidth?: 'full' | 'half' | 'third' | 'quarter';
+}
+
+interface FormConfig {
+  name: string;
+  slug?: string;
+  description?: string;
+  fieldConfigs: FormField[];
+  submitButtonText?: string;
+  successMessage?: string;
+}
+
+interface SubmitResult {
+  success: boolean;
+  submissionId?: string;
+  error?: string;
+}
+
+// ============================================================================
+// Configuration
+// ============================================================================
+
+const CONFIG = {
+  baseUrl: process.env.NEXT_PUBLIC_NETPAD_URL ?? 'https://api.netpad.io',
+  apiKey: process.env.NEXT_PUBLIC_NETPAD_API_KEY ?? '',
+};
+
+const formConfig: FormConfig = ${formConfig};
+
+// ============================================================================
+// API Functions (using fetch - no SDK required)
+// ============================================================================
+
+${includeApiSubmission ? `async function submitToApi(data: Record<string, unknown>): Promise<SubmitResult> {
+  try {
+    const response = await fetch(
+      \`\${CONFIG.baseUrl}/api/forms/${formSlug}/submit\`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+        },
+        body: JSON.stringify({ data }),
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return { success: false, error: errorText };
     }
-    code += `import type { FormConfiguration } from '@netpad/forms';
 
-`;
-    code += `const formConfig: FormConfiguration = ${formConfig};
+    const result = await response.json() as { submissionId: string };
+    return { success: true, submissionId: result.submissionId };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}` : ""}
+
+// ============================================================================
+// Component
+// ============================================================================
+
+export function ${componentName}() {
+  const [formData, setFormData] = useState<Record<string, string>>({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [submitResult, setSubmitResult] = useState<SubmitResult | null>(null);
+  const [errors, setErrors] = useState<Record<string, string>>({});
+
+  const handleChange = (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => {
+    const { name, value } = e.target;
+    setFormData(prev => ({ ...prev, [name]: value }));
+    // Clear error when field is edited
+    if (errors[name]) {
+      setErrors(prev => {
+        const newErrors = { ...prev };
+        delete newErrors[name];
+        return newErrors;
+      });
+    }
+  };
 
-`;
-    if (useNetPadClient) {
-      code += `const client = createNetPadClient({
-  baseUrl: process.env.NEXT_PUBLIC_NETPAD_URL || 'https://your-netpad-instance.com',
-  apiKey: process.env.NETPAD_API_KEY || '',
-});
+  const validateForm = (): boolean => {
+    const newErrors: Record<string, string> = {};
 
-`;
+    for (const field of formConfig.fieldConfigs) {
+      if (!field.included) continue;
+
+      const value = formData[field.path] || '';
+
+      if (field.required && !value) {
+        newErrors[field.path] = \`\${field.label} is required\`;
+      }
+
+      if (field.validation) {
+        if (field.validation.minLength && value.length < field.validation.minLength) {
+          newErrors[field.path] = field.validation.errorMessage || \`Minimum \${field.validation.minLength} characters required\`;
+        }
+        if (field.validation.maxLength && value.length > field.validation.maxLength) {
+          newErrors[field.path] = field.validation.errorMessage || \`Maximum \${field.validation.maxLength} characters allowed\`;
+        }
+        if (field.validation.pattern && !new RegExp(field.validation.pattern).test(value)) {
+          newErrors[field.path] = field.validation.errorMessage || 'Invalid format';
+        }
+      }
     }
-    code += `export function ${componentName}() {
-`;
-    if (includeSubmitHandler) {
-      if (useNetPadClient) {
-        code += `  const handleSubmit = async (data: Record<string, unknown>) => {
+
+    setErrors(newErrors);
+    return Object.keys(newErrors).length === 0;
+  };
+
+${includeSubmitHandler ? `  const handleSubmit = async (e: FormEvent) => {
+    e.preventDefault();
+
+    if (!validateForm()) return;
+
+    setIsSubmitting(true);
+    setSubmitResult(null);
+
     try {
-      const result = await client.submitForm(formConfig.formId || formConfig.slug || '', data);
-      console.log('Submission successful:', result);
-      // Handle success (e.g., show notification, redirect)
+${includeApiSubmission ? `      const result = await submitToApi(formData);
+      setSubmitResult(result);` : `      // TODO: Implement your submission logic
+      console.log('Form data:', formData);
+      setSubmitResult({ success: true });`}
     } catch (error) {
-      console.error('Submission failed:', error);
-      // Handle error
+      setSubmitResult({
+        success: false,
+        error: error instanceof Error ? error.message : 'Submission failed',
+      });
+    } finally {
+      setIsSubmitting(false);
     }
-  };
+  };` : ""}
 
-`;
-      } else {
-        code += `  const handleSubmit = async (data: Record<string, unknown>) => {
-    console.log('Form submitted:', data);
-    // TODO: Handle form submission
+  const renderField = (field: FormField) => {
+    if (!field.included) return null;
+
+    const commonProps = {
+      id: field.path,
+      name: field.path,
+      value: formData[field.path] || '',
+      onChange: handleChange,
+      required: field.required,
+      placeholder: field.placeholder,
+      disabled: isSubmitting,
+      className: \`form-field \${errors[field.path] ? 'error' : ''}\`,
+    };
+
+    let input;
+
+    switch (field.type) {
+      case 'long_text':
+        input = <textarea {...commonProps} rows={4} />;
+        break;
+      case 'email':
+        input = <input {...commonProps} type="email" />;
+        break;
+      case 'number':
+        input = <input {...commonProps} type="number" />;
+        break;
+      case 'phone':
+        input = <input {...commonProps} type="tel" />;
+        break;
+      case 'date':
+        input = <input {...commonProps} type="date" />;
+        break;
+      case 'dropdown':
+      case 'select':
+        input = (
+          <select {...commonProps}>
+            <option value="">Select...</option>
+            {field.options?.map(opt => (
+              <option key={opt.value} value={opt.value}>{opt.label}</option>
+            ))}
+          </select>
+        );
+        break;
+      default:
+        input = <input {...commonProps} type="text" />;
+    }
+
+    return (
+      <div key={field.path} className={\`form-group field-width-\${field.fieldWidth || 'full'}\`}>
+        <label htmlFor={field.path}>
+          {field.label}
+          {field.required && <span className="required">*</span>}
+        </label>
+        {input}
+        {field.helpText && <small className="help-text">{field.helpText}</small>}
+        {errors[field.path] && <span className="error-message">{errors[field.path]}</span>}
+      </div>
+    );
   };
 
-`;
-      }
-    }
-    code += `  return (
-    <FormRenderer
-      config={formConfig}
-      onSubmit={${includeSubmitHandler ? "handleSubmit" : "undefined"}}
-      mode="create"
-    />
+  if (submitResult?.success) {
+    return (
+      <div className="form-success">
+        <h3>\u2713 {formConfig.successMessage || 'Thank you for your submission!'}</h3>
+        {submitResult.submissionId && (
+          <p>Confirmation ID: {submitResult.submissionId}</p>
+        )}
+        <button onClick={() => {
+          setSubmitResult(null);
+          setFormData({});
+        }}>
+          Submit Another
+        </button>
+      </div>
+    );
+  }
+
+  return (
+    <div className="form-container">
+      <h2>{formConfig.name}</h2>
+      {formConfig.description && <p className="form-description">{formConfig.description}</p>}
+
+      <form onSubmit={${includeSubmitHandler ? "handleSubmit" : "(e) => e.preventDefault()"}}>
+        {formConfig.fieldConfigs.map(renderField)}
+
+        {submitResult?.error && (
+          <div className="form-error">
+            <p>Error: {submitResult.error}</p>
+          </div>
+        )}
+
+        <button type="submit" disabled={isSubmitting} className="submit-button">
+          {isSubmitting ? 'Submitting...' : (formConfig.submitButtonText || 'Submit')}
+        </button>
+      </form>
+
+      <style>{\`
+        .form-container {
+          max-width: 600px;
+          margin: 0 auto;
+          padding: 20px;
+        }
+        .form-group {
+          margin-bottom: 16px;
+        }
+        .form-group label {
+          display: block;
+          margin-bottom: 4px;
+          font-weight: 500;
+        }
+        .form-group input,
+        .form-group textarea,
+        .form-group select {
+          width: 100%;
+          padding: 8px 12px;
+          border: 1px solid #ddd;
+          border-radius: 4px;
+          font-size: 14px;
+        }
+        .form-group input:focus,
+        .form-group textarea:focus,
+        .form-group select:focus {
+          outline: none;
+          border-color: #1976d2;
+        }
+        .form-group .error {
+          border-color: #d32f2f;
+        }
+        .required {
+          color: #d32f2f;
+          margin-left: 4px;
+        }
+        .help-text {
+          display: block;
+          color: #666;
+          margin-top: 4px;
+        }
+        .error-message {
+          display: block;
+          color: #d32f2f;
+          font-size: 12px;
+          margin-top: 4px;
+        }
+        .submit-button {
+          background: #1976d2;
+          color: white;
+          padding: 12px 24px;
+          border: none;
+          border-radius: 4px;
+          cursor: pointer;
+          font-size: 16px;
+        }
+        .submit-button:hover {
+          background: #1565c0;
+        }
+        .submit-button:disabled {
+          background: #ccc;
+          cursor: not-allowed;
+        }
+        .form-success {
+          text-align: center;
+          padding: 40px;
+        }
+        .form-error {
+          background: #ffebee;
+          color: #c62828;
+          padding: 12px;
+          border-radius: 4px;
+          margin-bottom: 16px;
+        }
+        .field-width-half {
+          display: inline-block;
+          width: calc(50% - 8px);
+          margin-right: 8px;
+        }
+        .field-width-third {
+          display: inline-block;
+          width: calc(33.33% - 8px);
+          margin-right: 8px;
+        }
+        .field-width-quarter {
+          display: inline-block;
+          width: calc(25% - 8px);
+          margin-right: 8px;
+        }
+      \`}</style>
+    </div>
   );
 }
+
+export default ${componentName};
 `;
+    const output = createToolOutput({
+      code,
+      filename: `${componentName}.tsx`,
+      envVars: [
+        { name: "NEXT_PUBLIC_NETPAD_URL", description: "NetPad API URL (client-side accessible)", example: "https://api.netpad.io" },
+        { name: "NEXT_PUBLIC_NETPAD_API_KEY", description: "NetPad API key (client-side accessible)", example: "np_live_xxxxx" }
+      ],
+      dependencies: ["react"]
+    });
     return {
       content: [
         {
           type: "text",
-          text: code
+          text: formatToolOutput(output)
         }
       ]
     };
@@ -20643,7 +21982,7 @@ server.tool(
 );
 server.tool(
   "get_use_case_template",
-  "Get a pre-built template for common form use cases including form configuration and workflow setup.",
+  '[DEPRECATED - use browse_templates with templateType="use_case" and action="get"] Get a pre-built template for common form use cases including form configuration and workflow setup.',
   {
     useCase: external_exports.enum(["leadCapture", "eventRegistration", "feedbackSurvey"]).describe("The use case template to retrieve")
   },
@@ -21032,7 +22371,7 @@ ${context ? `
 }
 server.tool(
   "list_application_templates",
-  "List all available application templates for creating new NetPad applications. Templates include pre-configured forms, workflows, and settings.",
+  '[DEPRECATED - use browse_templates with templateType="application"] List all available application templates for creating new NetPad applications. Templates include pre-configured forms, workflows, and settings.',
   {
     category: external_exports.string().optional().describe('Filter by category (e.g., "lead-generation", "events", "surveys", "hr", "ecommerce")')
   },
@@ -21064,7 +22403,7 @@ server.tool(
 );
 server.tool(
   "get_application_template",
-  "Get detailed information about a specific application template including its forms, workflows, and field configurations.",
+  '[DEPRECATED - use browse_templates with templateType="application" and action="get"] Get detailed information about a specific application template including its forms, workflows, and field configurations.',
   {
     templateId: external_exports.enum(["contact-form", "lead-capture", "event-registration", "feedback-survey", "job-application", "order-form", "blank"]).describe("The template ID")
   },
@@ -21088,7 +22427,7 @@ server.tool(
 );
 server.tool(
   "create_application",
-  "Generate code to create a new NetPad application. Can use a template or start from scratch. Returns API code and configuration.",
+  "Generate a single, complete TypeScript file that creates a NetPad application with all forms and workflows. Run with `npx tsx` - no SDK required.",
   {
     name: external_exports.string().describe("Name of the application"),
     description: external_exports.string().optional().describe("Description of the application"),
@@ -21101,20 +22440,264 @@ server.tool(
     organizationId: external_exports.string().describe("Organization ID")
   },
   async (options) => {
-    const code = generateCreateApplicationCode(options);
-    const config2 = generateApplicationConfig(options);
-    return {
-      content: [{
-        type: "text",
-        text: `## Application Creation Code
+    const { name, description, templateId, icon, color, tags, projectId, organizationId } = options;
+    const slug = options.slug || name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    const template = templateId ? APPLICATION_TEMPLATES[templateId] : null;
+    const formConfigs = template?.structure.forms.map((form) => ({
+      name: form.name,
+      slug: form.slug,
+      fieldConfigs: form.fields.map((f) => ({ ...f, included: true })),
+      submitButtonText: "Submit",
+      successMessage: "Thank you for your submission!"
+    })) || [];
+    const workflowConfigs = template?.structure.workflows.map((workflow) => ({
+      name: workflow.name,
+      description: `Triggered on ${workflow.trigger}`,
+      nodes: [
+        {
+          id: "trigger_1",
+          type: workflow.trigger === "form_submission" ? "form-trigger" : "manual-trigger",
+          label: "Trigger",
+          position: { x: 100, y: 200 },
+          config: { formSlug: formConfigs[0]?.slug || "" },
+          enabled: true
+        },
+        ...workflow.steps.map((step, stepIdx) => ({
+          id: `step_${stepIdx + 1}`,
+          type: step.includes("email") ? "email-send" : step.includes("database") ? "mongodb-write" : "transform",
+          label: step.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+          position: { x: 100 + (stepIdx + 1) * 250, y: 200 },
+          config: {},
+          enabled: true
+        }))
+      ],
+      edges: [
+        { id: "edge_1", source: "trigger_1", sourceHandle: "form_data", target: "step_1", targetHandle: "input" }
+      ]
+    })) || [];
+    const configCode = `// Application Configuration
+const APPLICATION_CONFIG = {
+  name: ${JSON.stringify(name)},
+  description: ${JSON.stringify(description || `Application created from ${templateId || "scratch"}`)},
+  slug: ${JSON.stringify(slug)},
+  icon: ${JSON.stringify(icon || "\u{1F4CB}")},
+  color: ${JSON.stringify(color || "#00ED64")},
+  tags: ${JSON.stringify(tags || [])},
+  projectId: CONFIG.projectId,
+  organizationId: CONFIG.organizationId,
+};
 
-${code}
+// Form Configurations
+const FORM_CONFIGS: FormConfig[] = ${JSON.stringify(formConfigs, null, 2)};
 
-## Application Configuration
+// Workflow Configurations
+const WORKFLOW_CONFIGS: WorkflowConfig[] = ${JSON.stringify(workflowConfigs, null, 2)};`;
+    const functionsCode = `// ============================================================================
+// API Helper Functions
+// ============================================================================
 
-\`\`\`json
-${JSON.stringify(config2, null, 2)}
-\`\`\``
+async function apiCall<T>(
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<{ success: boolean; data?: T; error?: string }> {
+  try {
+    const response = await fetch(\`\${CONFIG.baseUrl}\${endpoint}\`, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      return { success: false, error };
+    }
+
+    const data = await response.json() as T;
+    return { success: true, data };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+  }
+}
+
+// ============================================================================
+// Application Setup Functions
+// ============================================================================
+
+async function createApplication(): Promise<string | null> {
+  console.log('\u{1F4F1} Creating application:', APPLICATION_CONFIG.name);
+
+  const result = await apiCall<{ application: { applicationId: string } }>('/api/applications', {
+    method: 'POST',
+    body: JSON.stringify(APPLICATION_CONFIG),
+  });
+
+  if (!result.success || !result.data) {
+    console.error('\u274C Failed to create application:', result.error);
+    return null;
+  }
+
+  console.log('\u2705 Application created:', result.data.application.applicationId);
+  return result.data.application.applicationId;
+}
+
+async function createForms(applicationId: string): Promise<string[]> {
+  const formIds: string[] = [];
+
+  for (const formConfig of FORM_CONFIGS) {
+    console.log('\u{1F4DD} Creating form:', formConfig.name);
+
+    const result = await apiCall<{ form: { formId: string } }>('/api/forms', {
+      method: 'POST',
+      body: JSON.stringify({
+        ...formConfig,
+        applicationId,
+        projectId: CONFIG.projectId,
+        organizationId: CONFIG.organizationId,
+      }),
+    });
+
+    if (result.success && result.data) {
+      console.log('\u2705 Form created:', result.data.form.formId);
+      formIds.push(result.data.form.formId);
+    } else {
+      console.error('\u274C Failed to create form:', formConfig.name, result.error);
+    }
+  }
+
+  return formIds;
+}
+
+async function createWorkflows(applicationId: string, formIds: string[]): Promise<string[]> {
+  const workflowIds: string[] = [];
+
+  for (const workflowConfig of WORKFLOW_CONFIGS) {
+    console.log('\u26A1 Creating workflow:', workflowConfig.name);
+
+    // Update trigger with actual form ID if available
+    const updatedNodes = workflowConfig.nodes.map(node => {
+      if (node.type === 'form-trigger' && formIds.length > 0) {
+        return { ...node, config: { ...node.config, formId: formIds[0] } };
+      }
+      return node;
+    });
+
+    const result = await apiCall<{ workflow: { id: string } }>('/api/workflows', {
+      method: 'POST',
+      body: JSON.stringify({
+        ...workflowConfig,
+        nodes: updatedNodes,
+        applicationId,
+        projectId: CONFIG.projectId,
+        organizationId: CONFIG.organizationId,
+      }),
+    });
+
+    if (result.success && result.data) {
+      console.log('\u2705 Workflow created:', result.data.workflow.id);
+      workflowIds.push(result.data.workflow.id);
+    } else {
+      console.error('\u274C Failed to create workflow:', workflowConfig.name, result.error);
+    }
+  }
+
+  return workflowIds;
+}
+
+async function activateWorkflows(workflowIds: string[]): Promise<void> {
+  for (const workflowId of workflowIds) {
+    console.log('\u{1F504} Activating workflow:', workflowId);
+
+    const result = await apiCall(\`/api/workflows/\${workflowId}/activate\`, {
+      method: 'POST',
+    });
+
+    if (result.success) {
+      console.log('\u2705 Workflow activated');
+    } else {
+      console.warn('\u26A0\uFE0F Failed to activate workflow:', result.error);
+    }
+  }
+}`;
+    const mainCode = `// ============================================================================
+// Main Setup Script
+// ============================================================================
+
+async function setup() {
+  console.log('\\n\u{1F680} Setting up ${name}...\\n');
+  console.log('Template: ${templateId || "blank"}');
+  console.log('Project: ${projectId}');
+  console.log('Organization: ${organizationId}\\n');
+
+  // Validate configuration
+  if (!CONFIG.apiKey) {
+    console.error('\u274C Error: NETPAD_API_KEY environment variable is required');
+    console.log('\\nSet it in your environment or .env file:');
+    console.log('  export NETPAD_API_KEY="np_live_xxxxx"\\n');
+    process.exit(1);
+  }
+
+  // Step 1: Create application
+  const applicationId = await createApplication();
+  if (!applicationId) {
+    process.exit(1);
+  }
+
+  // Step 2: Create forms
+  const formIds = await createForms(applicationId);
+  console.log(\`\\n\u{1F4CA} Created \${formIds.length} form(s)\\n\`);
+
+  // Step 3: Create workflows
+  const workflowIds = await createWorkflows(applicationId, formIds);
+  console.log(\`\\n\u26A1 Created \${workflowIds.length} workflow(s)\\n\`);
+
+  // Step 4: Activate workflows
+  if (workflowIds.length > 0) {
+    await activateWorkflows(workflowIds);
+  }
+
+  // Summary
+  console.log('\\n' + '='.repeat(50));
+  console.log('\u2705 Setup Complete!');
+  console.log('='.repeat(50));
+  console.log(\`
+Application: ${name}
+Application ID: \${applicationId}
+Forms: \${formIds.length}
+Workflows: \${workflowIds.length}
+
+Next steps:
+1. Visit your NetPad dashboard to customize forms and workflows
+2. Test form submissions
+3. Configure email templates and integrations
+\`);
+}
+
+// Run setup
+setup().catch((error) => {
+  console.error('\u274C Setup failed:', error);
+  process.exit(1);
+});`;
+    const code = generateSelfContainedCode({
+      title: `${name} Setup`,
+      description: description || `Complete setup script for ${name}`,
+      includeFormTypes: true,
+      includeWorkflowTypes: true,
+      configCode,
+      functionsCode,
+      mainCode
+    });
+    const output = createToolOutput({
+      code,
+      filename: `setup-${slug}.ts`,
+      envVars: STANDARD_ENV_VARS
+    });
+    return {
+      content: [{
+        type: "text",
+        text: formatToolOutput(output)
       }]
     };
   }
@@ -21573,7 +23156,7 @@ server.resource(
 );
 server.tool(
   "list_workflow_templates",
-  "List all available workflow templates for creating automated workflows.",
+  '[DEPRECATED - use browse_templates with templateType="workflow"] List all available workflow templates for creating automated workflows.',
   {
     category: external_exports.string().optional().describe('Filter by category (e.g., "notifications", "data", "sales")')
   },
@@ -21605,7 +23188,7 @@ server.tool(
 );
 server.tool(
   "get_workflow_template",
-  "Get detailed information about a specific workflow template including its nodes, edges, and configuration.",
+  '[DEPRECATED - use browse_templates with templateType="workflow" and action="get"] Get detailed information about a specific workflow template including its nodes, edges, and configuration.',
   {
     templateId: external_exports.enum(["form-to-email", "form-to-database", "lead-qualification", "webhook-to-database", "scheduled-report"]).describe("The template ID")
   },
@@ -21670,33 +23253,240 @@ server.tool(
 );
 server.tool(
   "create_workflow_from_template",
-  "Generate code to create a new workflow, optionally using a template.",
+  "Generate a complete, self-contained TypeScript file to create a workflow. Returns validated code with inline types - run with `npx tsx`.",
   {
     name: external_exports.string().describe("Name of the workflow"),
     description: external_exports.string().optional().describe("Description of the workflow"),
     templateId: external_exports.enum(["form-to-email", "form-to-database", "lead-qualification", "webhook-to-database", "scheduled-report"]).optional().describe("Template to use"),
+    formId: external_exports.string().optional().describe("Form ID for form-triggered workflows"),
+    formSlug: external_exports.string().optional().describe("Form slug for form-triggered workflows"),
     applicationId: external_exports.string().optional().describe("Application ID to attach workflow to"),
     projectId: external_exports.string().describe("Project ID"),
     organizationId: external_exports.string().describe("Organization ID"),
-    tags: external_exports.array(external_exports.string()).optional().describe("Tags for categorization")
+    tags: external_exports.array(external_exports.string()).optional().describe("Tags for categorization"),
+    salesEmail: external_exports.string().optional().describe("Email address for sales notifications")
   },
   async (options) => {
-    const code = generateCreateWorkflowCode(options);
-    const config2 = generateWorkflowConfig(options);
+    const { name, description, templateId, formId, formSlug, applicationId, tags, salesEmail } = options;
+    const slug = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    const template = templateId ? WORKFLOW_TEMPLATES[templateId] : null;
+    const workflowNodes = template?.nodes || [
+      {
+        id: "trigger_1",
+        type: "manual-trigger",
+        label: "Manual Trigger",
+        position: { x: 100, y: 200 },
+        config: {},
+        enabled: true
+      }
+    ];
+    const workflowEdges = template?.edges || [];
+    const updatedNodes = workflowNodes.map((node) => {
+      if (node.type === "form-trigger") {
+        return {
+          ...node,
+          config: {
+            ...node.config,
+            formId: formId || node.config.formId || "",
+            formSlug: formSlug || node.config.formSlug || ""
+          }
+        };
+      }
+      if (node.type === "email-send" && salesEmail) {
+        return {
+          ...node,
+          config: {
+            ...node.config,
+            to: salesEmail
+          }
+        };
+      }
+      return node;
+    });
+    const configCode = `// Workflow Configuration
+const WORKFLOW_CONFIG: WorkflowConfig = {
+  name: ${JSON.stringify(name)},
+  description: ${JSON.stringify(description || template?.description || "Custom workflow")},
+  tags: ${JSON.stringify(tags || template?.tags || [])},
+  nodes: ${JSON.stringify(updatedNodes, null, 2)},
+  edges: ${JSON.stringify(workflowEdges, null, 2)},
+  settings: {
+    executionMode: 'auto',
+    maxExecutionTime: 300000,
+    retryPolicy: {
+      maxRetries: 3,
+      backoffMultiplier: 2,
+      initialDelayMs: 1000,
+    },
+  },
+};`;
+    const functionsCode = `/**
+ * Create the workflow via NetPad API.
+ */
+export async function createWorkflow(): Promise<CreateWorkflowResult> {
+  try {
+    const response = await fetch(\`\${CONFIG.baseUrl}/api/workflows\`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+      },
+      body: JSON.stringify({
+        ...WORKFLOW_CONFIG,
+        ${applicationId ? `applicationId: '${applicationId}',` : ""}
+        projectId: CONFIG.projectId,
+        organizationId: CONFIG.organizationId,
+      }),
+    });
+
+    if (!response.ok) {
+      return { success: false, error: await response.text() };
+    }
+
+    const result = await response.json() as { workflow: { id: string } };
+    return { success: true, workflowId: result.workflow.id };
+  } catch (error) {
     return {
-      content: [{
-        type: "text",
-        text: `## Workflow Creation Code
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
 
-\`\`\`typescript
-${code}
-\`\`\`
+/**
+ * Activate the workflow to start processing.
+ */
+export async function activateWorkflow(workflowId: string): Promise<{ success: boolean; error?: string }> {
+  try {
+    const response = await fetch(
+      \`\${CONFIG.baseUrl}/api/workflows/\${workflowId}/activate\`,
+      {
+        method: 'POST',
+        headers: {
+          'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+        },
+      }
+    );
 
-## Workflow Configuration
+    if (!response.ok) {
+      return { success: false, error: await response.text() };
+    }
 
-\`\`\`json
-${JSON.stringify(config2, null, 2)}
-\`\`\``
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
+
+/**
+ * Test the workflow with sample data.
+ */
+export async function testWorkflow(workflowId: string, testData: Record<string, unknown>): Promise<{ success: boolean; executionId?: string; error?: string }> {
+  try {
+    const response = await fetch(
+      \`\${CONFIG.baseUrl}/api/workflows/\${workflowId}/execute\`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': \`Bearer \${CONFIG.apiKey}\`,
+        },
+        body: JSON.stringify({ payload: testData }),
+      }
+    );
+
+    if (!response.ok) {
+      return { success: false, error: await response.text() };
+    }
+
+    const result = await response.json() as { executionId: string };
+    return { success: true, executionId: result.executionId };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}`;
+    const mainCode = `// ============================================================================
+// Main Setup
+// ============================================================================
+
+async function setup() {
+  console.log('\u26A1 Creating workflow:', WORKFLOW_CONFIG.name);
+  console.log('Template: ${templateId || "custom"}');
+  ${formId ? `console.log('Form ID: ${formId}');` : ""}
+  ${formSlug ? `console.log('Form Slug: ${formSlug}');` : ""}
+  console.log('');
+
+  // Validate configuration
+  if (!CONFIG.apiKey) {
+    console.error('\u274C Error: NETPAD_API_KEY environment variable is required');
+    process.exit(1);
+  }
+
+  // Create the workflow
+  const createResult = await createWorkflow();
+  if (!createResult.success) {
+    console.error('\u274C Failed to create workflow:', createResult.error);
+    process.exit(1);
+  }
+
+  console.log('\u2705 Workflow created:', createResult.workflowId);
+
+  // Activate the workflow
+  console.log('\\n\u{1F504} Activating workflow...');
+  const activateResult = await activateWorkflow(createResult.workflowId!);
+  if (activateResult.success) {
+    console.log('\u2705 Workflow activated');
+  } else {
+    console.warn('\u26A0\uFE0F Failed to activate:', activateResult.error);
+  }
+
+  // Summary
+  console.log('\\n' + '='.repeat(50));
+  console.log('\u2705 Workflow Setup Complete!');
+  console.log('='.repeat(50));
+  console.log(\`
+Workflow: ${name}
+Workflow ID: \${createResult.workflowId}
+Nodes: ${updatedNodes.length}
+Edges: ${workflowEdges.length}
+${templateId ? `Template: ${templateId}` : ""}
+
+Next steps:
+1. Configure node settings in the NetPad dashboard
+2. Test with sample data
+3. Monitor executions
+\`);
+}
+
+// Uncomment to run:
+// setup().catch(console.error);
+
+// Export for use as module
+export { WORKFLOW_CONFIG, createWorkflow, activateWorkflow, testWorkflow };`;
+    const code = generateSelfContainedCode({
+      title: name,
+      description: description || `Workflow created from ${templateId || "scratch"}`,
+      includeFormTypes: false,
+      includeWorkflowTypes: true,
+      configCode,
+      functionsCode,
+      mainCode
+    });
+    const output = createToolOutput({
+      code,
+      filename: `${slug}-workflow.ts`,
+      envVars: STANDARD_ENV_VARS
+    });
+    return {
+      content: [{
+        type: "text",
+        text: formatToolOutput(output)
       }]
     };
   }
@@ -21881,7 +23671,7 @@ server.resource(
 );
 server.tool(
   "list_conversational_templates",
-  "List all available conversational form templates for AI-powered data collection.",
+  '[DEPRECATED - use browse_templates with templateType="conversational"] List all available conversational form templates for AI-powered data collection.',
   {
     category: external_exports.string().optional().describe('Filter by category (e.g., "support", "feedback", "intake")')
   },
@@ -21913,7 +23703,7 @@ server.tool(
 );
 server.tool(
   "get_conversational_template",
-  "Get detailed information about a specific conversational form template including topics, extraction schema, and persona configuration.",
+  '[DEPRECATED - use browse_templates with templateType="conversational" and action="get"] Get detailed information about a specific conversational form template including topics, extraction schema, and persona configuration.',
   {
     templateId: external_exports.enum(["it-helpdesk", "customer-feedback", "lead-qualification", "patient-intake"]).describe("The template ID")
   },
@@ -22228,7 +24018,7 @@ server.resource(
 );
 server.tool(
   "list_template_categories",
-  "List all available form template categories with descriptions and template counts.",
+  '[DEPRECATED - use browse_templates with templateType="form" and action="categories"] List all available form template categories with descriptions and template counts.',
   {},
   async () => {
     return {
@@ -22245,7 +24035,7 @@ server.tool(
 );
 server.tool(
   "list_form_templates",
-  "List all available form templates (25+) across multiple categories. Returns template summaries with field counts.",
+  '[DEPRECATED - use browse_templates with templateType="form"] List all available form templates (25+) across multiple categories. Returns template summaries with field counts.',
   {
     category: external_exports.string().optional().describe('Filter by category (business, events, feedback, support, ecommerce, healthcare, hr, finance, education, real-estate, or "all")'),
     search: external_exports.string().optional().describe("Search templates by name, description, or tags")
@@ -22284,7 +24074,7 @@ server.tool(
 );
 server.tool(
   "get_form_template",
-  "Get detailed information about a specific form template including all fields, validation rules, and configuration.",
+  '[DEPRECATED - use browse_templates with templateType="form" and action="get"] Get detailed information about a specific form template including all fields, validation rules, and configuration.',
   {
     templateId: external_exports.string().describe('Template ID (e.g., "contact-form", "lead-capture", "patient-intake")')
   },
@@ -22467,7 +24257,7 @@ ${code}
 );
 server.tool(
   "list_query_templates",
-  "List all available MongoDB query templates for common operations.",
+  '[DEPRECATED - use browse_templates with templateType="query"] List all available MongoDB query templates for common operations.',
   {},
   async () => {
     const templates = listQueryTemplates();
@@ -22484,7 +24274,7 @@ server.tool(
 );
 server.tool(
   "get_query_template",
-  "Get a specific query template with example code.",
+  '[DEPRECATED - use browse_templates with templateType="query" and action="get"] Get a specific query template with example code.',
   {
     templateId: external_exports.string().describe('Template ID (e.g., "find-all", "aggregate-group-count")')
   },