@swizzy_ai/kit 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -90,13 +90,18 @@ declare class LLMClient {
 interface BungeeDestination {
     type: 'step';
     targetId: string;
+    config?: Record<string, any>;
 }
+
 interface BungeePlan {
     id: string;
     anchorId: string;
     destinations: BungeeDestination[];
     concurrency: number;
-    configFn?: (index: number) => Record<string, any>;
+    optimistic?: boolean;
+    returnToAnchor?: boolean;
+    failWizardOnFailure?: boolean;
+    onComplete?: (wizard: any) => FlowControlSignal;
 }
 
 declare class BungeeBuilder {
@@ -105,17 +110,28 @@ declare class BungeeBuilder {
     /**
      * Add a single step execution.
      */
-    readonly add: (stepId: string) => this;
+    readonly add: (stepId: string, config?: Record<string, any>) => this;
     /**
      * Add multiple executions based on count with config function.
      */
-    readonly batch: (stepId: string, count: number, configFn: (index: number) => Record<string, any>) => this;
+    readonly batch: (stepId: string, count: number, configFn: (index: number) => Record<string, any>, options?: {
+        optimistic?: boolean;
+        returnToAnchor?: boolean;
+        failWizardOnFailure?: boolean;
+    }) => this;
     /**
      * Configure execution settings.
      */
     readonly config: (options: {
         concurrency?: number;
+        optimistic?: boolean;
+        returnToAnchor?: boolean;
+        failWizardOnFailure?: boolean;
     }) => this;
+    /**
+     * Set completion callback.
+     */
+    readonly onComplete: (callback: (wizard: any) => any) => this;
     /**
      * Trigger the Jump.
      */
@@ -127,6 +143,7 @@ declare class BungeeBuilder {
 
 interface WizardActions {
     updateContext: (updates: Record<string, any>) => void;
+    setState: (updates: Partial<any> | ((prevState: any) => Partial<any>)) => void;
     llmClient: LLMClient;
     goto: (stepId: string) => FlowControlSignal;
     next: () => FlowControlSignal;
@@ -142,7 +159,7 @@ type FlowControlSignal = 'NEXT' | 'STOP' | 'RETRY' | 'WAIT' | string | {
     type: 'BUNGEE_JUMP';
     plan: BungeePlan;
 };
-type Context = (workflowContext: any) => any;
+type Context = (workflowContext: any) => any | Promise<any>;
 type ContextType = 'xml' | 'template' | 'both';
 interface StepConfig<T = any> {
     id: string;
@@ -154,6 +171,7 @@ interface StepConfig<T = any> {
     beforeRun?: () => Promise<void> | void;
     afterRun?: (result: T) => Promise<void> | void;
     model: string;
+    stream?: boolean;
 }
 declare class Step<T = any> {
     readonly id: string;
@@ -165,10 +183,11 @@ declare class Step<T = any> {
     readonly beforeRun?: () => Promise<void> | void;
     readonly afterRun?: (result: T) => Promise<void> | void;
     readonly model: string;
+    readonly stream?: boolean;
     executionCount: number;
     constructor(config: StepConfig<T>);
     validate(data: unknown): T;
-    getContext(workflowContext: any): any;
+    getContext(workflowContext: any): Promise<any>;
 }
 
 interface TextStepConfig {
@@ -180,6 +199,7 @@ interface TextStepConfig {
     beforeRun?: () => Promise<void> | void;
     afterRun?: (result: string) => Promise<void> | void;
     model: string;
+    stream: boolean;
 }
 declare class TextStep extends Step<string> {
     constructor(config: TextStepConfig);
@@ -249,7 +269,7 @@ declare class Wizard {
     private isLoggingEnabled;
     private logger;
     private usageTracker;
-    private contextManager;
+    private stateManager;
     private visualizationManager;
     private bungeeExecutor;
     private events;
@@ -298,19 +318,24 @@ declare class Wizard {
      * Uses streaming for regular steps to provide real-time parsing and UI updates.
      * TextStep and ComputeStep use different approaches (non-streaming).
      */
+    /**
+      * Generates data for a wizard step by calling the LLM.
+      * CLEANED VERSION: Separates formatting rules from logic to prevent hallucination.
+      */
     generateStepData(step: Step, stepContext: any): Promise<any>;
     private repairSchemaData;
     /**
-     * Creates a streaming XML parser for incremental processing of LLM responses.
+     * Creates an improved streaming XML parser for incremental processing of LLM responses.
      *
-     * This parser processes XML chunks as they arrive from the LLM, extracting
-     * fields marked with tag-category="wizard" and parsing them based on their type attributes.
+     * This parser is designed to handle partial chunks robustly and provides better error recovery.
+     * It processes XML chunks as they arrive, extracting fields marked with tag-category="wizard".
      *
-     * Key features:
-     * - Incremental parsing: processes data as it streams in
-     * - Buffer management: accumulates chunks until complete fields are available
-     * - Type-aware parsing: handles strings, numbers, booleans, arrays, objects
-     * - Real-time updates: returns partial results as fields complete
+     * Key improvements:
+     * - Better partial tag handling
+     * - More robust regex matching
+     * - Improved buffer management
+     * - Better error recovery for malformed chunks
+     * - State machine approach for parsing
      *
      * @returns An object with a push method that accepts text chunks and returns parse results
      */