@atlashub/smartstack-cli 3.8.0 → 3.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",
@@ -80,6 +80,7 @@
     "test:all": "npm run test:mcp && npm run test:ba"
   },
   "dependencies": {
+    "@atlashub/smartstack-cli": "file:../02-Develop",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "axios": "^1.7.0",
     "bcryptjs": "^2.4.3",

package/templates/agents/action.md

@@ -3,6 +3,7 @@ name: action
 description: Conditional action executor - performs actions only when specific conditions are met
 color: purple
 model: haiku
+tools: Read, Glob, Grep, Bash
 ---
 
 Batch conditional executor. Handle ≤5 tasks. VERIFY INDEPENDENTLY before each action.

package/templates/agents/ba-writer.md

@@ -88,6 +88,102 @@ Merge a section into an existing feature.json.
 9. **Cross-Reference Validation (for specification and handoff sections):** See CROSS-REFERENCE VALIDATION section below
 10. Return confirmation with section size and status
 
+### enrichSectionIncremental
+Incrementally update a section in feature.json using PATCH-style operations instead of full section replacement. Optimized for large files and preventing file size issues.
+
+**Input:**
+- featureId: FEAT-NNN or full path to feature.json
+- section: one of [discovery, analysis, specification, validation, handoff, suggestions, cadrage, consolidation, modules, dependencyGraph, metadata.workflow]
+- operation: "merge" | "append" | "update" | "delete"
+- path: JSON path within the section (e.g., "entities[2]", "useCases", "modules[0].status")
+- data: the data to merge/append/update
+
+**Operations:**
+
+1. **merge** - Deep merge data into existing section
+   ```javascript
+   // Example: Add new entities to analysis.entities without rewriting entire analysis
+   enrichSectionIncremental({
+     featureId: "FEAT-001",
+     section: "analysis",
+     operation: "merge",
+     path: "entities",
+     data: [
+       { name: "NewEntity", description: "...", attributes: [...] }
+     ]
+   })
+   // Result: analysis.entities now has existing entities + NewEntity
+   ```
+
+2. **append** - Append item to an array
+   ```javascript
+   // Example: Add a single business rule without rewriting all rules
+   enrichSectionIncremental({
+     featureId: "FEAT-001",
+     section: "analysis",
+     operation: "append",
+     path: "businessRules",
+     data: { id: "BR-VAL-ABC-042", name: "...", statement: "..." }
+   })
+   ```
+
+3. **update** - Update specific field in section
+   ```javascript
+   // Example: Update module status without rewriting entire modules array
+   enrichSectionIncremental({
+     featureId: "FEAT-001",
+     section: "modules",
+     operation: "update",
+     path: "[0].status",  // Path to first module's status field
+     data: "handed-off"
+   })
+   ```
+
+4. **delete** - Remove item from section
+   ```javascript
+   // Example: Remove a specific entity
+   enrichSectionIncremental({
+     featureId: "FEAT-001",
+     section: "analysis",
+     operation: "delete",
+     path: "entities[2]"  // Delete third entity
+   })
+   ```
+
+**Process:**
+1. Find and read feature.json (use findFeature if given ID)
+2. Navigate to the specified section
+3. Apply the incremental operation:
+   - **merge**: Deep merge arrays (append unique items), shallow merge objects
+   - **append**: Push item to array at path
+   - **update**: Set value at path
+   - **delete**: Remove item at path
+4. Update metadata.updatedAt with current timestamp
+5. Update metadata.updatedBy with agent name
+6. Write back with pretty-print (2-space indent)
+7. **File Size Check:** If resulting file > 100KB, display WARNING
+8. Validate schema before writing
+9. **Cross-Reference Validation:** Same rules as enrichSection
+10. Return confirmation with operation summary and file size
+
+**File Size Management:**
+- Before write: Check if file would exceed 100KB
+- If > 100KB: Display WARNING with recommendation to split into smaller operations
+- If > 500KB: BLOCKING ERROR - file too large, must use smaller chunks
+- Track cumulative file size growth across operations
+
+**Advantages over enrichSection:**
+- 50-70% reduction in tokens for large sections
+- Avoids "file too large" errors by updating incrementally
+- Allows progressive enrichment without reading/writing entire sections
+- Better performance for repeated updates (e.g., module loop)
+
+**Use Cases:**
+- Adding entities one-by-one during module specification
+- Updating module status in master without rewriting all modules
+- Appending business rules progressively
+- Updating handoff sections module-by-module
+
 ### enrichModuleHandoff
 Write the handoff section into a module feature.json. Specialized operation for step-05 module loop.
 
@@ -203,6 +299,39 @@ Create a new version for refactoring or major changes.
 6. Append changelog entry with old and new versions
 7. Return paths of both versions
 
+### applyReview
+Apply corrections from a ba-review.json export to create a new version of the analysis.
+
+**Input:**
+- featureId: FEAT-NNN of the existing application
+- reviewData: parsed content of ba-review.json (with `_reviewMeta` envelope)
+
+**Process:**
+1. Validate `reviewData._reviewMeta` has `sourceVersion` and `sourceApplicationId`
+2. Determine version bump:
+   - If `_reviewMeta.changeSummary.modulesAdded.length > 0` OR `modulesRemoved.length > 0`: major bump (v1.0 → v2.0)
+   - Otherwise: minor bump (v1.0 → v1.1)
+3. Call `createVersion(featureId, "Review corrections applied")`
+4. Read the new version's master feature.json
+5. Apply reverse mapping from review data to feature.json (see `references/review-data-mapping.md`):
+   - `reviewData.cadrage.scope.vital[]` → `cadrage.globalScope.mustHave[]`
+   - `reviewData.cadrage.scope.important[]` → `cadrage.globalScope.shouldHave[]`
+   - `reviewData.cadrage.scope.optional[]` → `cadrage.globalScope.couldHave[]`
+   - `reviewData.cadrage.scope.excluded[]` → `cadrage.globalScope.outOfScope[]`
+   - `reviewData.cadrage.stakeholders[]` → reverse-map access/frequency back to involvement/frequency
+   - `reviewData.cadrage.risks[]` → `cadrage.risks[]`
+   - `reviewData.modules[]` → update `modules[]` (add/remove/modify)
+6. For each module in `reviewData.moduleSpecifications`:
+   - Reverse-map useCases, businessRules, entities, permissions back to module feature.json
+7. Preserve review comments in a new `review` section of the master feature.json:
+   - `review.comments`: all inline comments from `reviewData.comments`
+   - `review.specComments`: text comments from `reviewData.specComments`
+   - `review.wireframeComments`: wireframe feedback from `reviewData.wireframeComments`
+   - `review.appliedAt`: ISO timestamp
+8. Update metadata.updatedAt
+9. Write the updated feature.json
+10. Return confirmation with: new version path, changes applied count, comments preserved count
+
 ## Schema Validation Rules
 
 Perform these structural checks before every write:
@@ -441,6 +570,88 @@ Before EVERY enrichSection() call for specification or handoff sections, validat
 6. **Pretty-print JSON** - use 2-space indentation
 7. **Timestamp management** - always set metadata.updatedAt to current ISO timestamp on write
 8. **Idempotency** - calling the same operation twice with same data should produce same result
+9. **File size management** - check file size before write, use incremental operations for large files
+
+## File Size Management (CRITICAL)
+
+**Problem:** Large feature.json files (>100KB) can cause write failures and token exhaustion.
+
+**Solution:** Progressive monitoring and incremental operations.
+
+### Size Thresholds
+
+| File Size | Status | Action |
+|-----------|--------|--------|
+| < 50KB | ✓ Safe | Use enrichSection normally |
+| 50-100KB | ⚠ Warning | Display warning, recommend enrichSectionIncremental for next operations |
+| 100-500KB | ⚠ High | STRONGLY recommend enrichSectionIncremental, limit enrichSection use |
+| > 500KB | ✗ Critical | BLOCK enrichSection, REQUIRE enrichSectionIncremental or split file |
+
+### Pre-Write File Size Check
+
+Before EVERY write operation:
+
+```javascript
+const currentFileSize = getFileSize(featurePath);
+const estimatedNewSize = currentFileSize + newDataSize;
+
+if (estimatedNewSize > 100 * 1024) {  // 100KB
+  WARNING(`Feature.json will be ${formatBytes(estimatedNewSize)} after write`);
+  WARNING(`Recommend using enrichSectionIncremental for future operations`);
+}
+
+if (estimatedNewSize > 500 * 1024) {  // 500KB
+  BLOCKING_ERROR(`Feature.json would exceed 500KB (${formatBytes(estimatedNewSize)})`);
+  BLOCKING_ERROR(`Use enrichSectionIncremental instead of enrichSection`);
+  STOP;
+}
+```
+
+### Operation Selection Guide
+
+| Scenario | Recommended Operation | Reason |
+|----------|----------------------|--------|
+| First-time section write | `enrichSection` | No existing data, full write needed |
+| Module loop (3+ iterations) | `enrichSectionIncremental` | Avoids rewriting same data multiple times |
+| Large sections (>20KB) | `enrichSectionIncremental` | Reduces token usage by 50-70% |
+| File size > 100KB | `enrichSectionIncremental` (REQUIRED) | Prevents file size bloat |
+| Single field update | `enrichSectionIncremental` with `update` | Most efficient for targeted changes |
+
+### Monitoring & Reporting
+
+After EVERY write, report file size status:
+
+```
+✓ feature.json written successfully
+  Path: docs/business/HumanResources/Projects/business-analyse/v1.0/feature.json
+  Size: 87.3 KB (↑ 12.1 KB from previous)
+  Status: ⚠ Approaching 100KB threshold
+  Recommendation: Use enrichSectionIncremental for remaining modules
+```
+
+### Splitting Large Files (Advanced)
+
+If a module feature.json exceeds 500KB despite incremental operations:
+
+1. **Split specification section** into separate files:
+   - `specification-entities.json` (entities, relationships)
+   - `specification-rules.json` (business rules, validations)
+   - `specification-ui.json` (wireframes, sections, navigation)
+
+2. **Update feature.json** with file references:
+   ```json
+   {
+     "specification": {
+       "$ref": "./specification-entities.json",
+       "$ref2": "./specification-rules.json",
+       "$ref3": "./specification-ui.json"
+     }
+   }
+   ```
+
+3. **ba-reader** auto-resolves references when reading
+
+**Note:** File splitting is a LAST RESORT. Prefer enrichSectionIncremental first.
 
 ## Error Handling
 

package/templates/agents/explore-codebase.md

@@ -3,6 +3,7 @@ name: explore-codebase
 description: Use this agent whenever you need to explore the codebase to implement a feature.
 color: yellow
 model: haiku
+tools: Read, Glob, Grep, Bash
 ---
 
 You are a codebase exploration specialist. Your only job is to find and present ALL relevant code and logic for the requested feature.

package/templates/agents/explore-docs.md

@@ -3,6 +3,7 @@ name: explore-docs
 description: Use this agent IMMEDIATELY when the user asks about library features, implementation methods, "how to do X with Y library", documentation searches, or ANY question about using/implementing specific libraries or frameworks (in any language) - launches Context7 and WebFetch for precise technical information with code examples
 color: yellow
 model: haiku
+tools: Read, Glob, Grep, WebSearch, WebFetch, ToolSearch
 ---
 
 You are a documentation exploration specialist. Your mission is to retrieve precise, actionable documentation with code examples while eliminating superficial content.

package/templates/agents/fix-grammar.md

@@ -3,6 +3,7 @@ name: fix-grammar
 description: Use this agent to fix grammar and spelling errors in a single file while preserving formatting
 color: blue
 model: haiku
+tools: Read, Edit, Write, Glob, Grep
 ---
 
 You are DevProfCorrectorGPT, a professional text corrector. Fix grammar and spelling errors in the specified file while preserving all formatting and meaning.

package/templates/agents/snipper.md

@@ -3,6 +3,7 @@ name: Snipper
 description: Use this agent when you need to modify code. This agent is specialized to be fast. The output is small and optimized to code as fast as agent can.
 color: blue
 model: haiku
+tools: Read, Edit, Write, Glob, Grep
 ---
 
 You are a rapid code modification specialist. No explanations, just execute.

package/templates/skills/admin/SKILL.md

@@ -40,3 +40,9 @@ Manage SmartStack admin accounts. Wraps the `smartstack admin` CLI command with
 4. **Report result** - Show new credentials or error message
 
 </workflow>
+
+<success_criteria>
+- Admin command executed successfully or clear error displayed
+- New credentials shown to user (for reset)
+- SmartStack.app project correctly detected
+</success_criteria>

package/templates/skills/ai-prompt/SKILL.md

@@ -13,12 +13,12 @@ description: |
 
 # Skill AI Prompt SmartStack
 
-> **Architecture:** Prompt + Blocks → Provider + Model → Completion → Schema Validation
+> **Architecture:** Prompt + Blocks -> Provider + Model -> Completion -> Schema Validation
 > Multi-provider: OpenAI, Anthropic (Claude), Azure OpenAI, Google Gemini
 
 **Reference:** [_shared.md](../_shared.md) for common patterns
 
-## WHEN THIS SKILL ACTIVATES
+## When This Skill Activates
 
 | Trigger | Example |
 |---------|---------|
@@ -28,17 +28,17 @@ description: |
 | Text analysis | "Analyze the sentiment of comments" |
 | Keywords | "prompt", "GPT", "Claude", "IA", "completion", "LLM" |
 
-## AI FLOW
+## AI Flow
 
 ```
-Feature → IAiCompletionService.ExecutePromptAsync()
-    ↓
-Prompt + Blocks → Provider Instance → External API (OpenAI/Claude/Azure/Gemini)
-    ↓
-AI Response → OutputSchema Validation → Typed Result<T>
+Feature -> IAiCompletionService.ExecutePromptAsync()
+    |
+Prompt + Blocks -> Provider Instance -> External API (OpenAI/Claude/Azure/Gemini)
+    |
+AI Response -> OutputSchema Validation -> Typed Result<T>
 ```
 
-## MAIN ENTITIES
+## Main Entities
 
 ### AiProvider & AiModel
 - **Providers:** OpenAI, Anthropic, Azure OpenAI, Google
@@ -58,138 +58,27 @@ Configured instance: Code, Name, SystemContext, DefaultModel, MonthlyBudgetLimit
 ### OutputSchema
 JSON Schema for validation: Code, Name, JsonSchema, DotNetType
 
-## WORKFLOW INTEGRATION
+## Implementation
 
-### 1. Define the Use Case
-| Question | Impact |
-|----------|--------|
-| Content type? | Model choice |
-| Structured response? | OutputSchema |
-| Multi-language? | Language variables |
-| Budget limited? | ProviderInstance |
-| Real-time? | Streaming |
+See [steps/step-01-implementation.md](steps/step-01-implementation.md) for:
+- Workflow steps (define use case, create prompt, define schema, execute)
+- AI service interfaces (IAiCompletionService, IPromptService)
+- Frontend integration (API, hooks, components)
+- Advanced patterns (streaming, fallback provider)
 
-### 2. Create the Prompt
-```csharp
-var promptId = await _promptService.CreatePromptAsync(new CreatePromptRequest
-{
-    Code = "ticket-analyzer",
-    Name = "Ticket Analyzer",
-    Blocks = new[] {
-        new CreateBlockRequest {
-            BlockType = PromptBlockType.System,
-            Content = "Instructions...",
-            IsRequired = true
-        },
-        new CreateBlockRequest {
-            BlockType = PromptBlockType.User,
-            Content = "Ticket: {{ticketTitle}}\nDescription: {{ticketDescription}}",
-            IsRequired = true
-        }
-    }
-});
-```
-
-### 3. Define OutputSchema (if structured response)
-```csharp
-var schemaId = await _schemaService.CreateAsync(new CreateSchemaRequest
-{
-    Code = "ticket-analysis-result",
-    JsonSchema = @"{ ""type"": ""object"", ""required"": [""category"", ""priority""], ... }",
-    DotNetType = "SmartStack.Application.AI.TicketAnalysisResult"
-});
-```
-
-### 4. Execute the Prompt
-```csharp
-// Simple execution
-var result = await _aiService.ExecutePromptAsync(promptId, new Dictionary<string, object>
-{
-    ["ticketTitle"] = ticket.Title,
-    ["ticketDescription"] = ticket.Description
-});
-
-// With typed validation
-var typedResult = await _aiService.ExecutePromptWithValidationAsync<TicketAnalysisResult>(
-    promptId, variables);
-if (typedResult.Success && typedResult.IsValid) { /* use typedResult.Data */ }
-```
-
-## AI SERVICES
-
-### IAiCompletionService
-```csharp
-Task<AiCompletionResult> CompleteAsync(AiCompletionRequest request, CancellationToken ct);
-Task<AiCompletionResult> ExecutePromptAsync(Guid promptId, Dictionary<string, object>? variables, ...);
-Task<AiValidatedCompletionResult<T>> ExecutePromptWithValidationAsync<T>(Guid promptId, ...);
-Task<AiValidatedCompletionResult<T>> ExecutePromptByCodeWithValidationAsync<T>(string promptCode, ...);
-```
-
-### IPromptService
-```csharp
-Task<PromptDto> GetPromptByCodeAsync(string code, string? version = null);
-Task<string> RenderPromptAsync(string code, Dictionary<string, object>? variables);
-Task<Guid> CreatePromptAsync(CreatePromptRequest request);
-Task ActivatePromptAsync(Guid promptId);
-// Block management: AddBlockToPromptAsync, UpdateBlockAsync, ReorderBlocksAsync
-```
+## Checklist
 
-## FRONTEND INTEGRATION
-
-### API
-```typescript
-aiApi.getPrompts(status?, isTemplate?)
-aiApi.executePrompt(promptId, variables)
-aiApi.previewPrompt(promptId, variables)
-aiApi.getProviders() / aiApi.getModels(providerId?)
-aiApi.getSchemas() / aiApi.createSchema(data)
-```
-
-### Hook useAiCompletion
-```typescript
-const { execute, loading, error, result } = useAiCompletion<T>(promptCode);
-const data = await execute(variables);
 ```
-
-### Component AiAssistantButton
-```tsx
-<AiAssistantButton
-  promptCode="ticket-analyzer"
-  variables={{ ticketTitle, ticketDescription }}
-  onResult={(result) => handleAnalysis(result)}
-  label="Analyze with AI"
-/>
+- Prompt created (unique Code, Blocks, Variables, Version)
+- OutputSchema if structured response
+- Service with IAiCompletionService injected
+- Error handling + Logging (tokens, time)
+- Frontend: Hook/component, Loading, Error handling
+- ProviderInstance with budget limit
+- Tests: execution, variables, schema validation
 ```
 
-## ADVANCED PATTERNS
-
-### Streaming Response
-```typescript
-const reader = response.body?.getReader();
-while (true) { const { done, value } = await reader.read(); if (done) break; /* append chunk */ }
-```
-
-### Fallback Provider
-```csharp
-foreach (var provider in providers.OrderBy(p => p.Priority)) {
-    var result = await _aiService.ExecutePromptAsync(promptId, variables, providerId: provider.Id);
-    if (result.Success) return result;
-}
-```
-
-## CHECKLIST
-
-```
-□ Prompt created (unique Code, Blocks, Variables, Version)
-□ OutputSchema if structured response
-□ Service with IAiCompletionService injected
-□ Error handling + Logging (tokens, time)
-□ Frontend: Hook/component, Loading, Error handling
-□ ProviderInstance with budget limit
-□ Tests: execution, variables, schema validation
-```
-
-## ABSOLUTE RULES
+## Absolute Rules
 
 | DO | DON'T |
 |----|-------|
@@ -199,7 +88,7 @@ foreach (var provider in providers.OrderBy(p => p.Priority)) {
 | Log executions (tokens, duration) | Hardcode API keys |
 | Variables for dynamic content | Expose system prompts to frontend |
 
-## KEY FILES
+## Key Files
 
 | File | Role |
 |------|------|
@@ -209,3 +98,10 @@ foreach (var provider in providers.OrderBy(p => p.Priority)) {
 | `Application/Common/Interfaces/IAiCompletionService.cs` | Service interface |
 | `Infrastructure/Services/AI/AiCompletionService.cs` | Implementation |
 | `web/src/services/api/aiApi.ts` | Frontend API |
+
+<success_criteria>
+- Prompt entity created with OutputSchema validation
+- IAiCompletionService integration wired correctly
+- Error handling for API failures and quota limits implemented
+- Token usage logged per execution
+</success_criteria>

package/templates/skills/ai-prompt/steps/step-01-implementation.md

@@ -0,0 +1,122 @@
+# AI Prompt - Implementation Workflow
+
+## 1. Define the Use Case
+
+| Question | Impact |
+|----------|--------|
+| Content type? | Model choice |
+| Structured response? | OutputSchema |
+| Multi-language? | Language variables |
+| Budget limited? | ProviderInstance |
+| Real-time? | Streaming |
+
+## 2. Create the Prompt
+
+```csharp
+var promptId = await _promptService.CreatePromptAsync(new CreatePromptRequest
+{
+    Code = "ticket-analyzer",
+    Name = "Ticket Analyzer",
+    Blocks = new[] {
+        new CreateBlockRequest {
+            BlockType = PromptBlockType.System,
+            Content = "Instructions...",
+            IsRequired = true
+        },
+        new CreateBlockRequest {
+            BlockType = PromptBlockType.User,
+            Content = "Ticket: {{ticketTitle}}\nDescription: {{ticketDescription}}",
+            IsRequired = true
+        }
+    }
+});
+```
+
+## 3. Define OutputSchema (if structured response)
+
+```csharp
+var schemaId = await _schemaService.CreateAsync(new CreateSchemaRequest
+{
+    Code = "ticket-analysis-result",
+    JsonSchema = @"{ ""type"": ""object"", ""required"": [""category"", ""priority""], ... }",
+    DotNetType = "SmartStack.Application.AI.TicketAnalysisResult"
+});
+```
+
+## 4. Execute the Prompt
+
+```csharp
+// Simple execution
+var result = await _aiService.ExecutePromptAsync(promptId, new Dictionary<string, object>
+{
+    ["ticketTitle"] = ticket.Title,
+    ["ticketDescription"] = ticket.Description
+});
+
+// With typed validation
+var typedResult = await _aiService.ExecutePromptWithValidationAsync<TicketAnalysisResult>(
+    promptId, variables);
+if (typedResult.Success && typedResult.IsValid) { /* use typedResult.Data */ }
+```
+
+## AI Services
+
+### IAiCompletionService
+```csharp
+Task<AiCompletionResult> CompleteAsync(AiCompletionRequest request, CancellationToken ct);
+Task<AiCompletionResult> ExecutePromptAsync(Guid promptId, Dictionary<string, object>? variables, ...);
+Task<AiValidatedCompletionResult<T>> ExecutePromptWithValidationAsync<T>(Guid promptId, ...);
+Task<AiValidatedCompletionResult<T>> ExecutePromptByCodeWithValidationAsync<T>(string promptCode, ...);
+```
+
+### IPromptService
+```csharp
+Task<PromptDto> GetPromptByCodeAsync(string code, string? version = null);
+Task<string> RenderPromptAsync(string code, Dictionary<string, object>? variables);
+Task<Guid> CreatePromptAsync(CreatePromptRequest request);
+Task ActivatePromptAsync(Guid promptId);
+// Block management: AddBlockToPromptAsync, UpdateBlockAsync, ReorderBlocksAsync
+```
+
+## Frontend Integration
+
+### API
+```typescript
+aiApi.getPrompts(status?, isTemplate?)
+aiApi.executePrompt(promptId, variables)
+aiApi.previewPrompt(promptId, variables)
+aiApi.getProviders() / aiApi.getModels(providerId?)
+aiApi.getSchemas() / aiApi.createSchema(data)
+```
+
+### Hook useAiCompletion
+```typescript
+const { execute, loading, error, result } = useAiCompletion<T>(promptCode);
+const data = await execute(variables);
+```
+
+### Component AiAssistantButton
+```tsx
+<AiAssistantButton
+  promptCode="ticket-analyzer"
+  variables={{ ticketTitle, ticketDescription }}
+  onResult={(result) => handleAnalysis(result)}
+  label="Analyze with AI"
+/>
+```
+
+## Advanced Patterns
+
+### Streaming Response
+```typescript
+const reader = response.body?.getReader();
+while (true) { const { done, value } = await reader.read(); if (done) break; /* append chunk */ }
+```
+
+### Fallback Provider
+```csharp
+foreach (var provider in providers.OrderBy(p => p.Priority)) {
+    var result = await _aiService.ExecutePromptAsync(promptId, variables, providerId: provider.Id);
+    if (result.Success) return result;
+}
+```