sweagent 0.0.1

package/dist/index.cjs

@@ -0,0 +1,487 @@
+'use strict';var zod=require('zod'),ai=require('ai'),openai=require('@ai-sdk/openai'),anthropic=require('@ai-sdk/anthropic'),google=require('@ai-sdk/google'),client=require('@modelcontextprotocol/sdk/client'),module$1=require('module'),k=require('path'),url=require('url');var _documentCurrentScript=typeof document!=='undefined'?document.currentScript:null;function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var k__default=/*#__PURE__*/_interopDefault(k);var M=class extends Error{constructor(e,o){super(e,o===void 0?void 0:{cause:o}),this.name="LibraryError",o?.stack&&(this.stack=`${this.stack}
+Caused by: ${o.stack}`);}},C=class extends M{constructor(o,r,n){super(o,n);this.provider=r;this.name="ModelError";}},x=class extends M{constructor(o,r,n){super(o,n);this.toolName=r;this.name="ToolError";}},Ne=class extends M{constructor(o,r){super(o);this.errors=r;this.name="ValidationError";}},Y=class extends M{constructor(o,r,n){super(o,n);this.iteration=r;this.name="AgentError";}},D=class extends M{constructor(o,r,n){super(o,n);this.subagentName=r;this.name="SubagentError";}};var Ue={debug:0,info:1,warn:2,error:3};function Ht(t={}){let{prefix:e="",level:o="info",timestamps:r=false}=t,n=Ue[o];function i(a,p){let m=[];return r&&m.push(`[${new Date().toISOString()}]`),m.push(`[${a.toUpperCase()}]`),e&&m.push(`[${e}]`),m.push(p),m.join(" ")}function s(a){return Ue[a]>=n}return {debug(a,p){s("debug")&&console.debug(i("debug",a),p??"");},info(a,p){s("info")&&console.info(i("info",a),p??"");},warn(a,p){s("warn")&&console.warn(i("warn",a),p??"");},error(a,p){s("error")&&console.error(i("error",a),p??"");}}}var pt={noCacheTokens:void 0,cacheReadTokens:void 0,cacheWriteTokens:void 0},dt={textTokens:void 0,reasoningTokens:void 0};function ke(t){let e=0,o=0,r=0;for(let n of t)n&&(e+=n.inputTokens??0,o+=n.outputTokens??0,r+=n.totalTokens??0);return {inputTokens:e,outputTokens:o,totalTokens:r,inputTokenDetails:pt,outputTokenDetails:dt}}function h(t){let{name:e,description:o,input:r,handler:n}=t;return ai.tool({description:o,inputSchema:r,execute:async i=>{let s=r.safeParse(i);if(!s.success)throw new x(`Invalid input: ${s.error.message}`,e,s.error);try{return await n(s.data,void 0)}catch(a){throw a instanceof x?a:new x(`Tool "${e}" failed: ${a instanceof Error?a.message:String(a)}`,e,a instanceof Error?a:void 0)}}})}function I(t){return t}function _e(t){return Object.values(t)}function je(t,e){return t[e]}async function ce(t,e,o){if(!t.execute)return {success:false,error:"Tool has no execute function"};try{return {success:!0,output:await t.execute(e,{toolCallId:o?.toolCallId??"",messages:[],abortSignal:o?.abortSignal})}}catch(r){return {success:false,error:r instanceof Error?r.message:String(r)}}}async function H(t,e,o,r){let n=t[e];if(!n)throw new x(`Tool not found: ${e}`);return ce(n,o,r)}async function w(t){let{model:e,tools:o,systemPrompt:r,input:n,maxIterations:i=10,onStep:s}=t,a=[{role:"system",content:r},{role:"user",content:n}],p=[];for(let m=0;m<i;m++){let u=await e.invoke(a,{tools:o}),g={iteration:m,content:u.text,toolCalls:u.toolCalls,usage:u.usage};if(!u.toolCalls?.length)return p.push(g),s?.(g),{output:u.text,steps:p,totalUsage:ke(p.map(S=>S.usage)),messages:a};let y=[...u.text?[{type:"text",text:u.text}]:[],...u.toolCalls.map(S=>({type:"tool-call",toolCallId:S.toolCallId,toolName:S.toolName,input:S.input}))];a.push({role:"assistant",content:y});let G=[];for(let S of u.toolCalls){let J=await H(o,S.toolName,S.input,{toolCallId:S.toolCallId}),O={toolCallId:S.toolCallId,toolName:S.toolName,output:J.success?J.output:J.error,isError:!J.success};G.push(O);let ct=O.isError?{type:"error-text",value:String(O.output)}:{type:"text",value:typeof O.output=="string"?O.output:JSON.stringify(O.output)};a.push({role:"tool",content:[{type:"tool-result",toolCallId:S.toolCallId,toolName:S.toolName,output:ct}]});}g.toolResults=G,p.push(g),s?.(g);}throw new Y(`Agent reached maximum iterations (${i}) without completing`,i-1)}function N(t){let{provider:e,modelName:o,getModel:r}=t;return {provider:e,modelName:o,async invoke(n,i){try{let s=await r(),a=i?.tools?Object.fromEntries(Object.entries(i.tools).map(([u,g])=>{let{execute:y,...G}=g;return [u,G]})):void 0,p=await ai.generateText({model:s,messages:n,tools:a,maxOutputTokens:i?.maxOutputTokens,temperature:i?.temperature,stopSequences:i?.stop}),m=p.toolCalls.map(u=>({toolCallId:u.toolCallId,toolName:u.toolName,input:u.input}));return {text:p.text,toolCalls:m,usage:p.usage,finishReason:p.finishReason}}catch(s){let a=s instanceof Error?s:new Error(String(s));throw new C(`Failed to invoke ${e} model`,e,a)}},async generateVision(n,i,s){try{let a=await r(),p=[];for(let g of i)p.push({type:"image",image:`data:${g.mimeType};base64,${g.base64}`,mimeType:g.mimeType});p.push({type:"text",text:n});let m=[];s?.systemPrompt&&m.push({role:"system",content:s.systemPrompt}),m.push({role:"user",content:p});let u=await ai.generateText({model:a,messages:m,maxOutputTokens:s?.maxOutputTokens,temperature:s?.temperature});return {text:u.text,toolCalls:[],usage:u.usage,finishReason:u.finishReason}}catch(a){let p=a instanceof Error?a:new Error(String(a));throw new C("Failed to generate vision response",e,p)}}}}function Q(t){let{model:e,apiKey:o,baseUrl:r}=t,n=openai.createOpenAI({apiKey:o??process.env.OPENAI_API_KEY,baseURL:r});return N({provider:"openai",modelName:e,getModel:()=>n.chat(e)})}function V(t){let{model:e,apiKey:o}=t,r=anthropic.createAnthropic({apiKey:o??process.env.ANTHROPIC_API_KEY});return N({provider:"anthropic",modelName:e,getModel:()=>r(e)})}function W(t){let{model:e,apiKey:o}=t,r=google.createGoogleGenerativeAI({apiKey:o??process.env.GOOGLE_GENERATIVE_AI_API_KEY});return N({provider:"google",modelName:e,getModel:()=>r(e)})}function R(t){let{provider:e}=t;switch(e){case "openai":return Q(t);case "anthropic":return V(t);case "google":return W(t);default:throw new C(`Unsupported provider: ${e}. Supported providers: openai, anthropic, google`)}}var bt=/^[a-z0-9]+(-[a-z0-9]+)*$/;function v(t){if(!t.name.trim())throw new D("Subagent name is required",void 0);if(!bt.test(t.name))throw new D(`Subagent name must be kebab-case (lowercase letters, numbers, hyphens): ${t.name}`,t.name);return {...t}}function St(t,e){if(t.tools!=null&&Object.keys(t.tools).length>0)return t.tools;let o=e??{},r=new Set(t.disallowedTools??[]),n={};for(let[i,s]of Object.entries(o))i.startsWith("subagent_")||r.has(i)||(n[i]=s);return n}async function pe(t,e,o){let{parentTools:r,parentModel:n}=o??{},i=St(t,r),s=t.model==null?n:R(t.model);if(!s)throw new D("Subagent has no model: set definition.model or pass parentModel in options",t.name);return {...await w({model:s,tools:i,systemPrompt:t.systemPrompt,input:e,maxIterations:t.maxIterations??10,onStep:t.onStep}),subagentName:t.name}}function de(t,e){let o=`subagent_${t.name}`;return h({name:o,description:t.description,input:zod.z.object({prompt:zod.z.string().describe("The task or question to delegate to this subagent")}),handler:async({prompt:r})=>(await pe(t,r,{parentTools:e?.parentTools,parentModel:e?.parentModel})).output})}function U(t,e){let o={};for(let r of t){let n=de(r,e);o[`subagent_${r.name}`]=n;}return o}function xt(){let e=module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).resolve("@modelcontextprotocol/sdk/client");return k__default.default.dirname(k__default.default.dirname(k__default.default.dirname(k__default.default.dirname(e))))}var Fe=xt();function $e(t){let e=t.content;if(!e?.length)return {};let o=e[0];if(o?.type==="text"&&typeof o.text=="string"){let r=o.text.trim();if(r.startsWith("{")||r.startsWith("["))try{return JSON.parse(r)}catch{return {raw:r}}return {text:r}}return t}async function Be(t,e){let o=k__default.default.join(Fe,"dist","esm","client","streamableHttp.js"),r=await import(url.pathToFileURL(o).href),n=e?{headers:new Headers(e)}:void 0;return new r.StreamableHTTPClientTransport(new URL(t),n?{requestInit:n}:void 0)}async function Ge(t,e){let o=k__default.default.join(Fe,"dist","esm","client","stdio.js"),r=await import(url.pathToFileURL(o).href);return new r.StdioClientTransport({command:t,args:e})}var K=class{info;config;client=null;transport=null;connectPromise=null;constructor(e,o){this.info=e,this.config=o;}static resolveConfig(e,o={envPrefix:"MCP"}){let{envPrefix:r,serverLabel:n,apiKeyHeader:i}=o,s=e?.url??process.env[`${r}_URL`],a=process.env[`${r}_API_KEY`],p=e?.command??process.env[`${r}_COMMAND`],m=process.env[`${r}_ARGS`],u=e?.args??(m?m.split(",").map(y=>y.trim()):void 0),g=e?.headers?{...e.headers}:void 0;if(a){let y=i??"Authorization";g=g??{},g[y]=y==="Authorization"?`Bearer ${a}`:a;}if(s)return {url:s,headers:g};if(p)return {command:p,args:u?.length?u:[]};throw new x(`${n??r} uses MCP only. Set ${r}_URL or ${r}_COMMAND (and optionally ${r}_ARGS).`,"mcp_client")}async ensureConnected(){if(this.client)return this.client;if(this.connectPromise){if(await this.connectPromise,!this.client)throw new x("MCP connection failed.","mcp_client");return this.client}if(this.connectPromise=this.doConnect(),await this.connectPromise,this.connectPromise=null,!this.client)throw new x("MCP connection failed.","mcp_client");return this.client}async doConnect(){let e=new client.Client({name:this.info.name,version:this.info.version},{capabilities:{}});if(this.config.url)this.transport=await Be(this.config.url,this.config.headers);else if(this.config.command)this.transport=await Ge(this.config.command,this.config.args??[]);else throw new x("MCP config missing: provide url or command.","mcp_client");await e.connect(this.transport),this.client=e;}async callTool(e,o={}){let n=await(await this.ensureConnected()).callTool({name:e,arguments:o});return n&&typeof n=="object"&&"content"in n?$e(n):n}async close(){this.transport&&(await this.transport.close(),this.transport=null),this.client=null,this.connectPromise=null;}};var me=h({name:"hello_world",description:"Returns a greeting message for the given name",input:zod.z.object({name:zod.z.string().describe("Name to greet")}),handler:async({name:t})=>({greeting:`Hello, ${t}! Welcome to sweagent.`})});var Rt="You are a friendly greeter. Use the hello_world tool to greet users.";async function vt(t){let{input:e,model:o,systemPrompt:r=Rt,maxIterations:n=3,onStep:i}=t,s=R(o??{provider:"openai",model:"gpt-4o-mini"});return w({model:s,tools:{hello_world:me},systemPrompt:r,input:e,maxIterations:n,onStep:i})}var ue=zod.z.object({fieldName:zod.z.string().describe("fieldName must be in camelCase"),fieldType:zod.z.enum(["string","number","boolean","Types.ObjectId","Date","object","email","password","enum"]),isArray:zod.z.boolean(),isRequired:zod.z.boolean(),isUnique:zod.z.boolean(),values:zod.z.array(zod.z.string()).describe("Enum values if fieldType is enum, else empty array"),defaultVal:zod.z.union([zod.z.string(),zod.z.boolean(),zod.z.number(),zod.z.null()]).optional(),relationTo:zod.z.string().optional().describe("Module name for relations"),relationType:zod.z.enum(["one-to-one","many-to-one",""]).optional(),isPrivate:zod.z.boolean().describe("True if password field, else false")});var ge=zod.z.object({moduleName:zod.z.string().describe("camelCase, single word, never auth/authentication"),isUserModule:zod.z.boolean(),authMethod:zod.z.enum(["EMAIL_AND_PASSWORD","PHONE_AND_OTP",""]).optional(),emailField:zod.z.string().optional(),passwordField:zod.z.string().optional(),phoneField:zod.z.string().optional(),roleField:zod.z.string().optional(),permissions:zod.z.record(zod.z.string(),zod.z.array(zod.z.enum(["CREATE","READ","UPDATE","DELETE"]))).optional().describe("Permissions per role"),fields:zod.z.array(ue)});var A=zod.z.object({projectName:zod.z.string().describe("projectName must be in kebab-case"),projectDescription:zod.z.string(),modules:zod.z.array(ge),author:zod.z.string().default("sijeeshmiziha")});var P=`You are an expert MongoDB database architect with deep expertise in schema design, performance optimization, scalability, and domain-driven design. You analyze requirements systematically using a multi-phase approach to create production-ready database schemas.
+
+## ANALYSIS FRAMEWORK
+
+You MUST follow this 5-phase analysis process before generating the schema:
+
+### PHASE 1: Entity Discovery
+Systematically extract all entities from the provided requirements:
+
+1. **From dataInvolved fields**: Every item in user stories' dataInvolved[] array indicates a potential entity or field
+   - Pattern: "User Profile" \u2192 user collection with profile fields
+   - Pattern: "Order Items" \u2192 order collection + item collection with relationship
+   - Pattern: "Product Inventory" \u2192 product collection with inventory fields
+
+2. **From User Types (Actors)**: Each actor type may indicate a User variant or role
+   - Pattern: "Admin", "Customer", "Vendor" \u2192 User collection with role enum
+   - Pattern: "Guest" \u2192 May not need persistence, or limited session data
+
+3. **From User Flow Actions**: Action verbs reveal implicit entities
+   - "creates order" \u2192 Order collection
+   - "submits payment" \u2192 Payment collection
+   - "uploads document" \u2192 Document collection
+   - "sends message" \u2192 Message collection
+
+4. **From Flow States**: Transitions reveal status enums
+   - Flow: pending \u2192 approved \u2192 completed \u2192 Order.status enum
+   - Flow: draft \u2192 published \u2192 archived \u2192 Content.status enum
+
+### PHASE 2: Relationship Mapping
+For each entity pair, determine relationships based on:
+
+1. **Ownership Patterns** (from actor actions):
+   - "Customer places Order" \u2192 Order.customer (many-to-one to User)
+   - "Admin approves Request" \u2192 Request.approvedBy (many-to-one to User)
+   - "User creates Post" \u2192 Post.author (many-to-one to User)
+
+2. **Cardinality from Flow Context**:
+   - "User has one profile" \u2192 one-to-one
+   - "User places multiple orders" \u2192 many-to-one (Order \u2192 User)
+   - "Order contains items" \u2192 many-to-one (OrderItem \u2192 Order)
+
+3. **Shared Entities** (referenced across flows):
+   - Entity referenced by multiple actors \u2192 likely needs relationships to User
+   - Entity in multiple flows \u2192 likely a core/central entity
+
+4. **Bidirectional References** (for one-to-one):
+   - Include reference field in BOTH collections for one-to-one relationships
+
+### PHASE 3: Permission Derivation
+Map actors to RBAC permissions:
+
+1. **Role Extraction**: Each actor type becomes a role value
+   - actors: [Admin, Customer, Vendor] \u2192 role enum: ['admin', 'customer', 'vendor']
+
+2. **Permission Mining from User Stories**:
+   - "As Admin, I can delete users" \u2192 admin: ['CREATE', 'READ', 'UPDATE', 'DELETE'] on user
+   - "As Customer, I can view my orders" \u2192 customer: ['READ'] on order (own records)
+   - "As Vendor, I can update products" \u2192 vendor: ['CREATE', 'READ', 'UPDATE'] on product
+
+3. **Data Visibility Rules**:
+   - "view own" \u2192 READ permission with ownership filter
+   - "view all" \u2192 READ permission without filter
+   - "manage" \u2192 full CRUD permissions
+
+### PHASE 4: Query Pattern Inference
+Analyze flows to predict database access patterns:
+
+1. **Read Patterns** (suggest indexes):
+   - "list orders by date" \u2192 index on order.createdAt
+   - "search products by category" \u2192 index on product.category
+   - "find user by email" \u2192 unique index on user.email
+   - "filter by status" \u2192 index on status field
+
+2. **Write Patterns** (affect schema design):
+   - High-frequency writes \u2192 consider denormalization
+   - Audit requirements \u2192 add createdBy, updatedBy fields
+
+3. **Aggregation Needs** (from reporting flows):
+   - "view sales dashboard" \u2192 may need summary collections
+   - "generate reports" \u2192 ensure proper indexing for date ranges
+
+### PHASE 5: Schema Construction
+Synthesize all analyses into the final schema:
+
+1. **Module Definition**:
+   - One module per core entity
+   - camelCase module names (never 'auth' or 'authentication')
+   - Mark user modules with isUserModule: true
+
+2. **Field Completeness**:
+   - All fields from dataInvolved
+   - Relationship fields (Types.ObjectId with relationTo)
+   - Status/lifecycle fields (enum type with values from flow states)
+   - Audit fields: createdAt, updatedAt (Date, required)
+   - createdBy, updatedBy when flows mention "who did what"
+
+3. **Validation Constraints**:
+   - isRequired: true for fields mentioned in preconditions
+   - isUnique: true for identifier fields (email, slug, code)
+   - enum values from flow states and categorical data
+
+4. **Security Fields**:
+   - password fields: fieldType: 'password', isPrivate: true
+   - email fields: fieldType: 'email', isUnique: true
+
+## CORE CONSTRAINTS (MUST FOLLOW)
+
+1. **Primary Key**: _id with Types.ObjectId (auto-generated, do not include in fields)
+
+2. **Relationships**:
+   - One-to-One: Reference field in BOTH collections
+   - Many-to-One: Reference in the "many" side only
+   - Many-to-Many: ONLY when necessary, use intermediate collection
+   - One-to-Many: FORBIDDEN - invert to many-to-one from child
+
+3. **Data Types**:
+   - NO arrays of ObjectIds for relationships
+   - Timestamps: createdAt, updatedAt (Date) in EVERY collection
+   - Enums: Use fieldType: 'enum' with values array
+
+4. **Security**:
+   - NO separate "Auth" or "Authentication" collection
+   - NO token storage in database
+   - Password fields: isPrivate: true
+
+5. **Authorization (RBAC)**:
+   - Define permissions per role on user modules
+   - Format: {{ "roleName": ["CREATE", "READ", "UPDATE", "DELETE"] }}`;function fe(t){return `${P}
+
+Design a robust and efficient MongoDB database schema based on the following requirements:
+
+## Requirements
+${t}
+
+## Guidelines
+1. Use camelCase for module names and field names
+2. Include createdAt and updatedAt Date fields in every module
+3. Define proper relationships between modules
+4. Set appropriate permissions for user modules
+
+Return ONLY valid JSON matching the schema specified. No markdown code blocks, no explanations.`}function Ye(t){return !t||t.length===0?'No specific user types defined. Assume a general "User" role.':t.map((e,o)=>{let r=e.goals.filter(n=>n.trim()).join(`
+   - `);return `### ${o+1}. ${e.name}
+**Description:** ${e.description}
+**Goals:**
+   - ${r||"No specific goals defined"}`}).join(`
+
+`)}function He(t,e){return !t||t.length===0?"No specific user flows defined.":t.map((o,r)=>{let i=e.find(s=>s.id===o.actorId)?.name||"User";return `### ${r+1}. ${o.name}
+**Actor:** ${i}
+**Description:** ${o.description}
+**Trigger:** ${o.trigger||"User initiates action"}
+**Outcome:** ${o.outcome||"Action completed"}`}).join(`
+
+`)}function Qe(t,e){if(!t||t.length===0)return "No specific user stories defined.";let o=new Map;for(let i of t){let s=o.get(i.flowId)||[];s.push(i),o.set(i.flowId,s);}let r=[];for(let i of e){let s=o.get(i.id)||[];if(s.length!==0){r.push(`### Flow: ${i.name}
+`);for(let a of s){let p=a.preconditions.filter(y=>y.trim()),m=a.postconditions.filter(y=>y.trim()),u=a.dataInvolved.filter(y=>y.trim()),g=`**As a** ${a.actor}, **I want to** ${a.action}, **so that** ${a.benefit}
+`;p.length>0&&(g+=`
+**Preconditions:**
+${p.map(y=>`- ${y}`).join(`
+`)}
+`),m.length>0&&(g+=`
+**Postconditions:**
+${m.map(y=>`- ${y}`).join(`
+`)}
+`),u.length>0&&(g+=`
+**Data Involved (IMPORTANT - these indicate entities/fields):**
+${u.map(y=>`- ${y}`).join(`
+`)}
+`),r.push(g);}}}let n=t.filter(i=>!e.some(s=>s.id===i.flowId));if(n.length>0){r.push(`### Other Stories
+`);for(let i of n){let s=i.dataInvolved.filter(p=>p.trim()),a=`**As a** ${i.actor}, **I want to** ${i.action}, **so that** ${i.benefit}
+`;s.length>0&&(a+=`
+**Data Involved:** ${s.join(", ")}
+`),r.push(a);}}return r.join(`
+`)}function Ve(t){if(!t)return "No specific technical requirements. Use defaults.";let e=[];return e.push(`**Authentication:** ${t.authentication||"none"}`),t.authorization?(e.push("**Authorization (RBAC):** Enabled"),t.roles&&t.roles.length>0&&e.push(`**Defined Roles:** ${t.roles.join(", ")}`)):e.push("**Authorization:** Disabled"),t.realtime&&e.push("**Realtime Features:** Required (consider subscription patterns)"),t.fileUpload&&e.push("**File Upload:** Required (consider file/document collection)"),t.search&&e.push("**Search Functionality:** Required (consider text indexes)"),t.integrations&&t.integrations.length>0&&e.push(`**Integrations:** ${t.integrations.join(", ")}`),e.join(`
+`)}function he(t){let e=new Set;for(let o of t)for(let r of o.dataInvolved)r.trim()&&e.add(r.trim());return Array.from(e)}function ye(t){return t.map(e=>e.name.toLowerCase().replaceAll(/\s+/g,"_"))}function We(t){return {projectName:t.projectName,projectGoal:t.projectGoal,projectDescription:t.projectDescription||t.projectGoal,userTypes:Ye(t.actors),userFlows:He(t.flows,t.actors),userStories:Qe(t.stories,t.flows),technicalRequirements:Ve(t.technicalRequirements)}}function be(t){let e=We(t);return `${P}
+
+---
+
+## PROJECT CONTEXT
+
+**Project Name:** ${e.projectName}
+**Project Goal:** ${e.projectGoal}
+**Description:** ${e.projectDescription}
+
+---
+
+## USER TYPES (ACTORS)
+
+These are the different types of users who will interact with the system. Each actor represents a potential role in your RBAC system.
+
+${e.userTypes}
+
+---
+
+## USER FLOWS
+
+These represent the key journeys users take through the system. Analyze these for:
+- Entity creation/modification patterns
+- State transitions (status enums)
+- Relationship ownership
+
+${e.userFlows}
+
+---
+
+## USER STORIES WITH DATA REQUIREMENTS
+
+Each story includes dataInvolved - these are CRITICAL signals for your entity and field design.
+
+${e.userStories}
+
+---
+
+## TECHNICAL REQUIREMENTS
+
+${e.technicalRequirements}
+
+---
+
+## YOUR TASK
+
+Follow the 5-phase analysis framework:
+
+### Step 1: Entity Discovery
+- List ALL entities extracted from dataInvolved fields
+- Identify implicit entities from user flow actions
+- Map user types to User collection roles
+- Extract status enums from flow transitions
+
+### Step 2: Relationship Mapping
+- Define ownership: which actor creates/owns each entity
+- Determine cardinality from flow context
+- Identify bidirectional relationships
+
+### Step 3: Permission Derivation
+- Map each actor to a role
+- Extract CRUD permissions from user story actions
+- Define the permissions object for user modules
+
+### Step 4: Query Pattern Inference
+- Identify likely query patterns from flows
+- Note which fields need indexing (for your reference)
+
+### Step 5: Schema Construction
+Generate the final schema with:
+- Complete module definitions
+- All fields with proper types
+- Relationships with relationTo and relationType
+- Status enums from flow states
+- RBAC permissions on user modules
+- Timestamps on every module
+
+Return ONLY valid JSON matching the schema specified. No markdown code blocks, no explanations.`}function Se(t,e){return `${P}
+
+Update the existing MongoDB schema based on user feedback.
+
+## Steps
+1. Analyze the existing MongoDB schema provided
+2. Review the user feedback to understand the required updates
+3. Update the schema to incorporate the requested changes while adhering to best practices
+
+## Existing Schema
+${t}
+
+## User Feedback
+${e}
+
+Return the updated schema as a valid JSON object matching the original schema format.
+IMPORTANT: Return ONLY the JSON object, no markdown code blocks, no explanations.`}var _=h({name:"validate_schema",description:"Validates a MongoDB project schema JSON string against the expected schema. Returns valid: true or valid: false with errors array.",input:zod.z.object({schema:zod.z.string().describe("JSON string of the database project schema to validate")}),handler:async({schema:t})=>{try{let e=JSON.parse(t);return A.parse(e),{valid:!0}}catch(e){return e instanceof zod.z.ZodError?{valid:false,errors:e.issues.map(o=>`${o.path.join(".")}: ${o.message}`)}:e instanceof SyntaxError?{valid:false,errors:[`Invalid JSON: ${e.message}`]}:{valid:false,errors:[String(e)]}}}});function At(t){let e=t.trim(),o=/```(?:json)?\s*([\s\S]*?)```/.exec(e);return o?.[1]?o[1].trim():e}function Z(t){return h({name:"design_database",description:"Generate a MongoDB database schema from plain text requirements. Use for ad-hoc or legacy requirements. Returns the full project schema as JSON.",input:zod.z.object({requirement:zod.z.string().describe("Plain text description of the database requirements")}),handler:async({requirement:e})=>{let o=fe(e),r=[{role:"system",content:"You are a MongoDB schema expert. Return only valid JSON."},{role:"user",content:o}],i=(await t.invoke(r,{temperature:.3,maxOutputTokens:8192})).text,s=At(i),a=JSON.parse(s);return A.parse(a)}})}function Pt(t){let e=t.trim(),o=/```(?:json)?\s*([\s\S]*?)```/.exec(e);return o?.[1]?o[1].trim():e}var Mt=zod.z.object({projectName:zod.z.string(),projectGoal:zod.z.string(),projectDescription:zod.z.string().optional(),actors:zod.z.array(zod.z.object({id:zod.z.string(),name:zod.z.string(),description:zod.z.string(),goals:zod.z.array(zod.z.string())})),flows:zod.z.array(zod.z.object({id:zod.z.string(),actorId:zod.z.string(),name:zod.z.string(),description:zod.z.string(),trigger:zod.z.string(),outcome:zod.z.string()})),stories:zod.z.array(zod.z.object({id:zod.z.string(),flowId:zod.z.string(),actor:zod.z.string(),action:zod.z.string(),benefit:zod.z.string(),preconditions:zod.z.array(zod.z.string()),postconditions:zod.z.array(zod.z.string()),dataInvolved:zod.z.array(zod.z.string())})),technicalRequirements:zod.z.object({authentication:zod.z.enum(["none","email","oauth","phone","email_and_phone"]),authorization:zod.z.boolean(),roles:zod.z.array(zod.z.string()).optional(),integrations:zod.z.array(zod.z.string()).optional(),realtime:zod.z.boolean().optional(),fileUpload:zod.z.boolean().optional(),search:zod.z.boolean().optional()}).optional()});function X(t){return h({name:"design_database_pro",description:"Generate a MongoDB schema from structured requirements (project name, goal, actors, flows, user stories with dataInvolved, technical requirements). Use for pro-level 5-phase analysis. Returns dbDesign and metadata (entitiesDetected, rolesExtracted).",input:Mt,handler:async e=>{let o=be(e),r=[{role:"system",content:"You are a MongoDB schema expert. Return only valid JSON."},{role:"user",content:o}],n=await t.invoke(r,{temperature:.2,maxOutputTokens:16384}),i=Pt(n.text),s=JSON.parse(i),a=A.parse(s),p={entitiesDetected:he(e.stories),rolesExtracted:ye(e.actors)};return {dbDesign:a,metadata:p}}})}function Ct(t){let e=t.trim(),o=/```(?:json)?\s*([\s\S]*?)```/.exec(e);return o?.[1]?o[1].trim():e}function ee(t){return h({name:"redesign_database",description:"Update an existing MongoDB project schema based on user feedback. Provide the current schema JSON string and the feedback. Returns the updated schema as JSON.",input:zod.z.object({existingSchema:zod.z.string().describe("Current project schema as JSON string"),feedback:zod.z.string().describe("User feedback describing desired changes")}),handler:async({existingSchema:e,feedback:o})=>{let r=Se(e,o),n=[{role:"system",content:"You are a MongoDB schema expert. Return only valid JSON."},{role:"user",content:r}],i=await t.invoke(n,{temperature:.3,maxOutputTokens:8192}),s=Ct(i.text),a=JSON.parse(s);return A.parse(a)}})}function we(t){return {validate_schema:_,design_database:Z(t),design_database_pro:X(t),redesign_database:ee(t)}}var It=`You are an expert at analyzing software requirements to extract database design signals.
+
+Focus on PHASES 1-3 of the analysis framework:
+
+## PHASE 1: Entity Discovery
+- List every entity implied by the requirements (from dataInvolved, user types, flow actions, flow states).
+- Identify user/actor types that become roles.
+- Extract status enums from flow transitions.
+
+## PHASE 2: Relationship Mapping
+- For each entity pair, determine ownership (which actor creates/owns it).
+- Determine cardinality (one-to-one, many-to-one).
+- Note bidirectional relationships.
+
+## PHASE 3: Permission Derivation
+- Map each actor type to a role name.
+- From user story actions, infer CRUD permissions per role per entity.
+
+Respond with a clear, structured analysis (you can use headings and bullet points). The user will use this to generate or refine a MongoDB schema.`,te=v({name:"entity-analyzer",description:"Analyzes raw requirements text to extract entities, relationships, and roles. Use when you need to understand what data and actors the system has before designing the schema. Returns structured analysis (no JSON).",systemPrompt:It,tools:{},maxIterations:2});var Et=`You are an expert MongoDB schema reviewer. Your job is to:
+
+1. Validate the provided schema using the validate_schema tool.
+2. Compare the schema against the original requirements and identify gaps (missing fields, wrong relationships, missing permissions).
+3. Suggest concrete improvements or return a corrected schema description.
+
+When the user gives you a schema (as JSON string) and optionally the original requirements, first call validate_schema to check structure. Then analyze completeness and correctness. Respond with either refinement suggestions or a summary of issues.`;function oe(){return v({name:"schema-refiner",description:"Validates a MongoDB project schema and suggests refinements based on requirements. Use when you have a draft schema and want to check it or improve it. Has access to validate_schema tool.",systemPrompt:Et,tools:{validate_schema:_},maxIterations:5})}var Ot=`${P}
+
+You are the database design orchestrator. When the user asks for a database design:
+
+1. **Analyze first**: For complex or vague requirements, use subagent_entity-analyzer with a prompt that includes the user's requirements to get a structured analysis of entities, relationships, and roles.
+2. **Generate schema**: Use design_database (for plain text requirements) or design_database_pro (when the user provides structured requirements: project name, goal, actors, flows, user stories with dataInvolved, technical requirements) to produce the MongoDB schema.
+3. **Refine (optional)**: If the user wants validation or refinements, use subagent_schema-refiner with the current schema and requirements.
+4. **Validate**: You can use validate_schema to check any schema JSON before returning.
+5. **Redesign**: If the user asks for changes to an existing schema, use redesign_database with the existing schema string and their feedback.
+
+Respond with the final schema (as JSON) or a clear summary and the schema.`;async function Dt(t){let{input:e,model:o,maxIterations:r=15,onStep:n}=t,i=R(o??{provider:"openai",model:"gpt-4o-mini"}),s=we(i),a=oe(),p=U([te,a],{parentModel:i}),m={...s,...p};return w({model:i,tools:m,systemPrompt:Ot,input:e,maxIterations:r,onStep:n})}var Re=zod.z.object({brandName:zod.z.string().describe("The brand's display name"),primaryColor:zod.z.string().describe("The brand's primary color code (e.g., #FFFFFF)"),secondaryColor:zod.z.string().describe("The brand's secondary color code (e.g., #000000)"),logo:zod.z.url().describe("URL pointing to the brand's logo")});var ve=zod.z.object({name:zod.z.string().describe("Application name"),description:zod.z.string().describe("Brief description of the application"),author:zod.z.string().describe("Author or owner of the application").default("sijeeshmiziha (HubSpire)"),branding:Re.describe("Branding information for the application"),apiEndpoint:zod.z.url().describe("URL endpoint for the app's API calls")});var Ze=zod.z.object({minLength:zod.z.number().optional().describe("Minimum length requirement"),zodString:zod.z.string().describe("Raw Zod string validation (e.g. regex)")}),Xe=zod.z.object({hookName:zod.z.string().optional().describe("Name of the hook for dynamic field options"),queryString:zod.z.string().optional().describe("Optional query string for fetching field options"),labelKey:zod.z.string().optional().describe("Key used as label when displaying options"),valueKey:zod.z.string().optional().describe("Key used as value for a field when selecting options"),values:zod.z.array(zod.z.string()).optional().describe("Static list of possible field values")}),re=zod.z.object({name:zod.z.string().describe("The field's key or identifier"),type:zod.z.enum(["text","email","password","number","multiSelect","textarea","hidden","select","date","image"]).describe('Type of input field. If it has options, it should not be "hidden". If the field is required, it should not be hidden unless it serves as the current user.'),required:zod.z.boolean().optional().describe("Whether this field must be filled"),validation:Ze.optional().describe("Optional field validation requirements"),defaultValue:zod.z.union([zod.z.string(),zod.z.number(),zod.z.boolean()]).optional().describe("Default value can be string, number, or boolean"),options:Xe.optional().describe("Additional dynamic or static options for this field")}),Ae=zod.z.object({field:zod.z.string().describe("Key or name of the data field in the table"),label:zod.z.string().describe("User-friendly label to show on the table header")});var Me=zod.z.object({type:zod.z.string().describe("Indicates the response type (e.g., 'object')"),properties:zod.z.record(zod.z.string(),zod.z.object({type:zod.z.string().describe("Property type as returned by the API")})).describe("Key-value record describing each field in the response")}).optional().describe("Describes the expected structure of an API response"),et=zod.z.object({type:zod.z.enum(["list","create","update","delete","getById"]).describe("Type of API call for CRUD operations"),graphqlHook:zod.z.string().describe("Name of the GraphQL hook (e.g. useGetAllUserQuery, useCreateUserMutation)"),queryString:zod.z.string().describe("Actual GraphQL query string"),responseType:Me.describe("Optional schema describing shape of the API response")}),tt=zod.z.object({type:zod.z.enum(["login","currentUser","forgotPassword","resetPassword"]).describe("Type of API call"),graphqlHook:zod.z.string().describe("Name of the GraphQL hook (e.g. useLoginMutation)"),queryString:zod.z.string().describe("Actual GraphQL query string"),responseType:Me.describe("Optional schema describing shape of the API response")}),Pe=zod.z.object({title:zod.z.string().describe("Title displayed on the drawer"),graphqlHook:zod.z.string().describe("Name of the GraphQL hook (e.g. useCreateUserMutation, useDeleteOneUserMutation)"),fields:zod.z.array(re).describe("List of fields displayed within the drawer")}),ot=zod.z.object({name:zod.z.enum(["LoginPage","ForgotPasswordPage","ResetPasswordPage"]).describe("Internal name of the auth page"),type:zod.z.enum(["EmailPassword","ForgotPassword","ResetPassword"]).describe("Type of authentication page"),route:zod.z.string().describe("URL route for this page (e.g., '/login')"),isPrivate:zod.z.boolean().describe("Whether this page requires an authenticated session"),api:zod.z.array(tt).describe("List of API calls involved in this page"),fields:zod.z.array(re).optional().describe("Optional form fields needed on this auth page")}),rt=zod.z.object({type:zod.z.literal("Listing").describe("Indicates that this page is a listing-type page"),name:zod.z.string().describe("Internal name of the listing page"),route:zod.z.string().describe("URL route for this listing page"),isPrivate:zod.z.boolean().describe("Whether this page is private (requires auth)"),api:zod.z.array(et).describe("List of API calls that power this listing page"),columns:zod.z.array(Ae).describe("Table columns displayed on the listing page"),actions:zod.z.array(zod.z.string()).describe("List of possible actions on each row (e.g., create, edit, delete, view)"),drawerCreate:Pe.describe("Drawer configuration for creating new records"),drawerUpdate:Pe.describe("Drawer configuration for editing existing records")}),Ce=zod.z.discriminatedUnion("type",[ot,rt]);var nt=zod.z.object({name:zod.z.string().describe("Name of the module"),pages:zod.z.array(Ce).describe("Pages included within this module")}),$=zod.z.object({app:ve.describe("Overall application configuration"),modules:zod.z.array(nt).describe("List of modules that make up the application. Ensure all modules use every available CRUD GraphQL query and mutation from the schema.")});var Nt=zod.z.object({email:zod.z.email().describe("User's email address, must be valid format"),password:zod.z.string().min(8).describe("User's password, minimum length of 8")}),at=zod.z.object({_id:zod.z.string().describe("Unique identifier of the specialization, type: string"),title:zod.z.string().describe("Display title for the specialization, type: string")}),Ut=zod.z.object({_id:zod.z.string().describe("Unique ID of the user, type: string"),firstName:zod.z.string().min(2).max(30).describe("First name, 2-30 characters, type: string"),lastName:zod.z.string().min(2).max(30).describe("Last name, 2-30 characters, type: string"),email:zod.z.email().describe("Email address in valid format, type: string"),phoneNumber:zod.z.string().min(10).describe("User's phone number, at least 10 digits, type: string"),profileImage:zod.z.string().optional().describe("Optional URL to user's profile image, type: string, optional"),role:zod.z.enum(["ADMIN","TRAINER","CLIENT"]).describe("User's role in the system (ADMIN, TRAINER, CLIENT)"),rate:zod.z.number().min(1).optional().describe("User's rate (e.g., hourly, etc.), type: number, optional"),specializations:zod.z.array(at).optional().describe("Array of specialization objects, optional"),languages:zod.z.array(zod.z.string()).optional().describe("Array of languages the user speaks, type: string[], optional"),about:zod.z.string().min(20).max(500).optional().describe("Brief bio or description (20-500 chars), type: string, optional"),gender:zod.z.string().optional().describe("User's gender, type: string, optional"),timezone:zod.z.string().optional().describe("User's timezone, type: string, optional"),averageRating:zod.z.number().optional().describe("Average rating for this user, type: number, optional")}),kt=zod.z.object({firstName:zod.z.string().min(2).max(30).describe("First name, 2-30 characters, type: string"),lastName:zod.z.string().min(2).max(30).describe("Last name, 2-30 characters, type: string"),email:zod.z.email().describe("Valid email for the new user, type: string"),phoneNumber:zod.z.string().min(10).describe("Phone number (at least 10 digits), type: string"),password:zod.z.string().min(8).describe("Password with min length 8, type: string"),role:zod.z.enum(["ADMIN","TRAINER","CLIENT"]).describe("Role of the new user (ADMIN, TRAINER, CLIENT)"),rate:zod.z.number().min(1).optional().describe("Rate for the new user, type: number, optional"),specializationIds:zod.z.array(zod.z.string()).min(1).optional().describe("Array of specialization IDs, optional"),languages:zod.z.array(zod.z.string()).min(1).optional().describe("List of languages user speaks, optional"),about:zod.z.string().min(20).max(500).optional().describe("User's about/bio field, 20-500 chars, optional")}),_t=zod.z.object({_id:zod.z.string().describe("ID of the user to be updated, type: string"),firstName:zod.z.string().min(2).max(30).optional().describe("Updated first name, type: string, optional"),lastName:zod.z.string().min(2).max(30).optional().describe("Updated last name, type: string, optional"),email:zod.z.email().optional().describe("Updated email, type: string, optional"),phoneNumber:zod.z.string().min(10).optional().describe("Updated phone number, at least 10 digits, optional"),rate:zod.z.number().min(1).optional().describe("Updated rate, type: number, optional"),specializationIds:zod.z.array(zod.z.string()).min(1).optional().describe("Updated array of specialization IDs, optional"),languages:zod.z.array(zod.z.string()).min(1).optional().describe("Updated list of languages, optional"),about:zod.z.string().min(20).max(500).optional().describe("Updated about/bio (20-500 chars), optional")}),jt=zod.z.object({email:zod.z.email().describe("Email to initiate the password reset process, type: string")}),Lt=zod.z.object({type:zod.z.enum(["EMAIL","SMS"]).describe("How the reset code was sent (EMAIL or SMS)"),resetTicket:zod.z.string().describe("Token/ticket to validate the reset request, type: string"),newPassword:zod.z.string().min(8).describe("The new password, min length 8, type: string")});var B=`You are an expert GraphQL-to-frontend configuration converter. Transform the provided GraphQL schema into a structured JSON configuration for rapid app development.
+
+**Your output must be valid JSON only.** No markdown code fences, no explanations. Return the raw JSON object matching the application schema (app with name, description, author, branding, apiEndpoint; modules array with name and pages; each page has type, name, route, isPrivate, api, and for listing pages: columns, actions, drawerCreate, drawerUpdate; for auth pages: fields when needed).
+
+Strict guidelines:
+- Use every available CRUD GraphQL query and mutation from the project schema.
+- Map GraphQL types to frontend modules and pages.
+- EmailAddress \u2192 "type": "email" with validation; DateTime \u2192 "type": "date"; enums \u2192 select with options.values.
+- Relationships \u2192 multiSelect with query-based options where appropriate.
+- Add isPrivate: true for authenticated operations.
+- Maintain camelCase. Ensure valid JSON syntax.`;var ne=`
+Act as an expert GraphQL-to-frontend configuration converter. Transform the provided schema into a structured JSON configuration for rapid app development.
+
+**Conversion Process**
+
+1. Schema Analysis:
+- Identify all modules using 100% of available CRUD operations
+- Catalog all Query/Mutation operations with arguments
+- Map GraphQL types to frontend modules
+- Detect @auth directives and role requirements
+- Analyze relationships through nested types
+
+2. Field Mapping:
+- EmailAddress \u2192 "type": "email" with Zod email validation
+- DateTime \u2192 "type": "date"
+- Enums \u2192 dropdowns with options.values
+- Relationships \u2192 multiSelect with query-based options
+
+3. API Operations:
+- For each Query/Mutation: determine CRUD type, generate query string with variables, map to React Hook, define response type shape
+
+4. Validation:
+- Generate Zod schemas from @required directives, scalar types (Password \u2192 min 8 chars), custom directives
+- Include validation error messages
+
+5. Security:
+- Add isPrivate: true for authenticated operations
+- Implement role checks from @auth directives
+
+6. Output:
+- Generate complete CRUD pages with table column mappings, validated Create/Update forms, API hooks
+- Include Zod validation strings, maintain camelCase, valid JSON only
+`.trim();function Ie(){return ne}var it=`
+type Query {
+  getCurrentUser: User
+  getAllUser(limit: Int, offset: Int): [User]!
+}
+type Mutation {
+  login(data: LoginInput!): Login!
+  createUser(data: CreateUserInput!): User!
+}
+type User {
+  _id: ID!
+  firstName: String!
+  lastName: String!
+  email: String!
+  role: Role!
+}
+enum Role { ADMIN TRAINER CLIENT }
+input LoginInput { email: String! password: String! }
+input CreateUserInput { firstName: String! lastName: String! email: String! role: Role! }
+`.trim(),st=`{
+  "app": {
+    "name": "my-app",
+    "description": "App description",
+    "author": "Author",
+    "branding": {
+      "brandName": "MyBrand",
+      "primaryColor": "#333",
+      "secondaryColor": "#fff",
+      "logo": "https://example.com/logo.png"
+    },
+    "apiEndpoint": "http://localhost:4000/graphql"
+  },
+  "modules": [
+    {
+      "name": "auth",
+      "pages": [
+        {
+          "name": "LoginPage",
+          "type": "EmailPassword",
+          "route": "/login",
+          "isPrivate": false,
+          "api": [
+            { "type": "login", "graphqlHook": "useLoginMutation", "queryString": "mutation Login($data: LoginInput!) { login(data: $data) { accessToken } }" }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "user",
+      "pages": [
+        {
+          "type": "Listing",
+          "name": "UserListPage",
+          "route": "/users",
+          "isPrivate": true,
+          "api": [
+            { "type": "list", "graphqlHook": "useGetAllUserQuery", "queryString": "query GetAllUser { getAllUser { _id firstName email } }" },
+            { "type": "create", "graphqlHook": "useCreateUserMutation", "queryString": "mutation CreateUser($data: CreateUserInput!) { createUser(data: $data) { _id } }" }
+          ],
+          "columns": [{ "field": "firstName", "label": "First Name" }, { "field": "email", "label": "Email" }],
+          "actions": ["create", "edit", "delete"],
+          "drawerCreate": { "title": "Create User", "graphqlHook": "useCreateUserMutation", "fields": [{ "name": "firstName", "type": "text", "required": true }, { "name": "email", "type": "email", "required": true }] },
+          "drawerUpdate": { "title": "Edit User", "graphqlHook": "useUpdateUserMutation", "fields": [{ "name": "firstName", "type": "text" }, { "name": "email", "type": "email" }] }
+        }
+      ]
+    }
+  ]
+}`;function Ee(){return `
+**Reference Conversion Example**
+
+EXAMPLE GRAPHQL INPUT:
+\`\`\`graphql
+${it}
+\`\`\`
+
+EXPECTED JSON OUTPUT:
+\`\`\`json
+${st}
+\`\`\`
+`.trim()}function qt(t,e){return `
+Review the user feedback carefully to understand the required updates.
+
+The user feedback for updating the generated Frontend Config JSON is provided below:
+"""
+${t}
+"""
+
+Now, generate the Frontend Config JSON for this project based on the provided feedback.
+
+**Project GRAPHQL SCHEMA INPUT:**
+\`\`\`graphql
+${e}
+\`\`\`
+
+Update the Frontend Config JSON to incorporate the requested changes. Return ONLY valid JSON, no markdown code blocks.
+`.trim()}var j=h({name:"validate_frontend_config",description:"Validates a frontend configuration JSON string against the ApplicationSchema. Returns valid: true or valid: false with errors array.",input:zod.z.object({config:zod.z.string().describe("JSON string of the frontend application config to validate")}),handler:async({config:t})=>{try{let e=JSON.parse(t);return $.parse(e),{valid:!0}}catch(e){return e instanceof zod.z.ZodError?{valid:false,errors:e.issues.map(o=>`${o.path.join(".")}: ${o.message}`)}:e instanceof SyntaxError?{valid:false,errors:[`Invalid JSON: ${e.message}`]}:{valid:false,errors:[String(e)]}}}});function zt(t){let e=t.trim(),o=/```(?:json)?\s*([\s\S]*?)```/.exec(e);return o?.[1]?o[1].trim():e}function Ft(t,e){let o=Ie(),r=Ee(),n=e?`
+**Project context:**
+- name: ${e.projectName??"project"}
+- description: ${e.projectDescription??""}
+- modules: ${e.modules??""}
+- apiEndpoint: ${e.apiEndpoint??"http://localhost:4000/graphql"}
+`:"";return `${o}
+
+${r}
+${n}
+
+**Current Project GraphQL Schema:**
+\`\`\`graphql
+${t}
+\`\`\`
+
+Generate the Frontend Config JSON. Use every available CRUD GraphQL query and mutation. Return ONLY valid JSON.`}function ae(t){return h({name:"generate_frontend",description:"Convert a GraphQL schema into a frontend configuration JSON (app, modules, pages, fields, API hooks). Optionally provide app info (project name, description, apiEndpoint). Returns the full application config as JSON.",input:zod.z.object({graphqlSchema:zod.z.string().describe("The GraphQL schema string to convert"),appInfo:zod.z.object({projectName:zod.z.string().optional(),projectDescription:zod.z.string().optional(),modules:zod.z.string().optional(),apiEndpoint:zod.z.string().optional()}).optional().describe("Optional project/app context")}),handler:async({graphqlSchema:e,appInfo:o})=>{let r=Ft(e,o),n=[{role:"system",content:B},{role:"user",content:r}],i=await t.invoke(n,{temperature:.2,maxOutputTokens:16384}),s=zt(i.text),a=JSON.parse(s);return $.parse(a)}})}function ie(t){return h({name:"generate_feature_breakdown",description:"Analyze a GraphQL schema and produce a feature/component breakdown: list of modules, CRUD operations, and suggested pages. Returns a structured summary (not the full frontend JSON).",input:zod.z.object({graphqlSchema:zod.z.string().describe("The GraphQL schema string to analyze")}),handler:async({graphqlSchema:e})=>{let o=`${ne}
+
+**Schema to analyze:**
+\`\`\`graphql
+${e}
+\`\`\`
+
+Respond with a structured breakdown only (no full JSON config): list modules, list Query/Mutation operations, and suggested pages for each module. Use clear headings and bullet points.`,r=[{role:"system",content:"You are a GraphQL schema analyst. Return a clear, structured text breakdown."},{role:"user",content:o}];return {summary:(await t.invoke(r,{temperature:.3,maxOutputTokens:4096})).text,modules:[],operations:[],suggestedPages:[]}}})}function De(t){return {validate_frontend_config:j,generate_frontend:ae(t),generate_feature_breakdown:ie(t)}}var $t=`You are an expert at analyzing GraphQL schemas. Your job is to:
+
+1. **Types**: List all object types, enums, scalars, and input types.
+2. **Queries**: List every Query field with arguments and return type.
+3. **Mutations**: List every Mutation field with arguments and return type.
+4. **Relationships**: Identify types that reference other types (e.g. User has role: Role, or Order has customer: User).
+5. **Auth/directives**: Note any @auth, @directive usage that affects access control.
+
+Respond with a clear, structured analysis (headings and bullet points). The user will use this to generate a frontend configuration.`,se=v({name:"graphql-analyzer",description:"Analyzes a GraphQL schema to extract types, queries, mutations, and relationships. Use when you need to understand the schema before generating frontend config. Returns structured analysis (no JSON).",systemPrompt:$t,tools:{},maxIterations:2});var Bt=`You are a frontend configuration validator. Your job is to:
+
+1. Validate the provided frontend config JSON using the validate_frontend_config tool.
+2. Compare the config against the GraphQL schema (if provided) and check that all CRUD operations are covered.
+3. Report any missing modules, pages, or API hooks.
+
+When the user gives you a config (as JSON string) and optionally the GraphQL schema, first call validate_frontend_config to check structure. Then summarize completeness.`;function le(){return v({name:"config-validator",description:"Validates a frontend configuration JSON and checks completeness against the GraphQL schema. Use when you have a draft config and want to validate it. Has access to validate_frontend_config tool.",systemPrompt:Bt,tools:{validate_frontend_config:j},maxIterations:5})}var Gt=`${B}
+
+You are the React frontend builder orchestrator. When the user provides a GraphQL schema and asks for a frontend configuration:
+
+1. **Analyze (optional)**: For complex schemas, use subagent_graphql-analyzer with a prompt that includes the schema to get a structured analysis of types, queries, and mutations.
+2. **Generate**: Use generate_frontend with the GraphQL schema (and optional appInfo) to produce the frontend config JSON.
+3. **Validate (optional)**: Use subagent_config-validator with the generated config (and schema) to check structure and completeness.
+4. **Validate directly**: You can use validate_frontend_config to check any config JSON.
+5. **Feature breakdown**: Use generate_feature_breakdown to get a module/operation breakdown before generating.
+
+Respond with the final frontend config (as JSON) or a clear summary and the config. If the user gives feedback, use generate_frontend again with the same schema and consider their feedback in your instructions.`;async function Jt(t){let{input:e,model:o,maxIterations:r=15,onStep:n}=t,i=R(o??{provider:"openai",model:"gpt-4o-mini"}),s=De(i),a=le(),p=U([se,a],{parentModel:i}),m={...s,...p};return w({model:i,tools:m,systemPrompt:Gt,input:e,maxIterations:r,onStep:n})}Object.defineProperty(exports,"jsonSchema",{enumerable:true,get:function(){return ai.jsonSchema}});Object.defineProperty(exports,"tool",{enumerable:true,get:function(){return ai.tool}});exports.AgentError=Y;exports.ApiResponseTypeSchema=Me;exports.AppConfigSchema=ve;exports.ApplicationSchema=$;exports.AuthPageApiSchema=tt;exports.AuthPageSchema=ot;exports.BaseMcpClient=K;exports.BrandingSchema=Re;exports.ColumnSchema=Ae;exports.CreateUserInputSchema=kt;exports.DB_DESIGN_SYSTEM_PROMPT=P;exports.DrawerSchema=Pe;exports.EXAMPLE_GRAPHQL_SCHEMA=it;exports.EXAMPLE_JSON_OUTPUT=st;exports.FieldOptionsSchema=Xe;exports.ForgotPasswordSchema=jt;exports.FormFieldSchema=re;exports.LibraryError=M;exports.ListingPageApiSchema=et;exports.ListingPageSchema=rt;exports.LoginInputSchema=Nt;exports.ModelError=C;exports.ModuleSchema=nt;exports.PageSchema=Ce;exports.REACT_BUILDER_INSTRUCTION=ne;exports.REACT_BUILDER_SYSTEM_PROMPT=B;exports.ResetPasswordSchema=Lt;exports.SpecializationSchema=at;exports.SubagentError=D;exports.ToolError=x;exports.UpdateUserInputSchema=_t;exports.UserSchema=Ut;exports.ValidationError=Ne;exports.ValidationSchema=Ze;exports.buildExampleShotPrompt=Ee;exports.buildFeedbackPrompt=qt;exports.buildInstructionPrompt=Ie;exports.buildPromptVariables=We;exports.createAnthropicModel=V;exports.createConfigValidatorSubagent=le;exports.createDbDesignPrompt=fe;exports.createDbDesignerTools=we;exports.createDesignDatabaseProTool=X;exports.createDesignDatabaseTool=Z;exports.createGenerateFeatureBreakdownTool=ie;exports.createGenerateFrontendTool=ae;exports.createGoogleModel=W;exports.createLogger=Ht;exports.createModel=R;exports.createOpenAIModel=Q;exports.createProDbDesignPrompt=be;exports.createReactBuilderTools=De;exports.createRedesignDatabaseTool=ee;exports.createRedesignPrompt=Se;exports.createSchemaRefinerSubagent=oe;exports.createSubagentTool=de;exports.createSubagentToolSet=U;exports.createToolSet=I;exports.defineSubagent=v;exports.defineTool=h;exports.entityAnalyzerSubagent=te;exports.executeTool=ce;exports.executeToolByName=H;exports.extractDataEntities=he;exports.extractRoles=ye;exports.fieldSchema=ue;exports.formatTechnicalRequirements=Ve;exports.formatUserFlows=He;exports.formatUserStories=Qe;exports.formatUserTypes=Ye;exports.getTool=je;exports.getTools=_e;exports.graphqlAnalyzerSubagent=se;exports.helloWorldTool=me;exports.moduleSchema=ge;exports.projectSchema=A;exports.runAgent=w;exports.runDbDesignerAgent=Dt;exports.runHelloWorldAgent=vt;exports.runReactBuilderAgent=Jt;exports.runSubagent=pe;exports.sumTokenUsage=ke;exports.validateFrontendConfigTool=j;exports.validateSchemaTool=_;//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map