@olane/o-lane 0.7.12-alpha.76 → 0.7.12

package/dist/src/ag-ui/ag-ui-constants.js

@@ -1,113 +0,0 @@
-/**
- * AG-UI Protocol Constants
- */
-/**
- * AG-UI protocol version this implementation supports
- */
-export const AG_UI_PROTOCOL_VERSION = '1.0.0';
-/**
- * Default configuration values
- */
-export const AG_UI_DEFAULTS = {
-    /**
-     * Default state snapshot interval (every N cycles)
-     */
-    STATE_SNAPSHOT_INTERVAL: 5,
-    /**
-     * Maximum delta history to keep
-     */
-    MAX_DELTA_HISTORY: 100,
-    /**
-     * Default text chunk size for streaming
-     */
-    TEXT_CHUNK_SIZE: 100,
-    /**
-     * Enable debug logging by default
-     */
-    DEBUG_ENABLED: false,
-    /**
-     * Enable AG-UI by default
-     */
-    AGUI_ENABLED: true,
-    /**
-     * Emit activity events by default
-     */
-    EMIT_ACTIVITY_EVENTS: true,
-    /**
-     * Emit reasoning events by default
-     */
-    EMIT_REASONING_EVENTS: true,
-    /**
-     * Include raw events by default
-     */
-    INCLUDE_RAW_EVENTS: false,
-    /**
-     * Auto-generate thread ID by default
-     */
-    AUTO_GENERATE_THREAD_ID: true,
-};
-/**
- * Activity types for AG-UI activity events
- */
-export const ACTIVITY_TYPES = {
-    PLAN: 'PLAN',
-    EXECUTE: 'EXECUTE',
-    EVALUATE: 'EVALUATE',
-    SEARCH: 'SEARCH',
-    CONFIGURE: 'CONFIGURE',
-    ERROR: 'ERROR',
-    PROGRESS: 'PROGRESS',
-};
-/**
- * Event type categories for filtering
- */
-export const EVENT_CATEGORIES = {
-    LIFECYCLE: [
-        'RunStarted',
-        'RunFinished',
-        'RunError',
-        'StepStarted',
-        'StepFinished',
-    ],
-    MESSAGES: [
-        'TextMessageStart',
-        'TextMessageContent',
-        'TextMessageEnd',
-        'TextMessageChunk',
-    ],
-    TOOL_CALLS: [
-        'ToolCallStart',
-        'ToolCallArgs',
-        'ToolCallEnd',
-        'ToolCallResult',
-        'ToolCallChunk',
-    ],
-    STATE: ['StateSnapshot', 'StateDelta', 'MessagesSnapshot'],
-    ACTIVITY: ['ActivitySnapshot', 'ActivityDelta'],
-    SPECIAL: ['Raw', 'Custom'],
-    REASONING: [
-        'ReasoningStart',
-        'ReasoningEnd',
-        'ReasoningMessageStart',
-        'ReasoningMessageContent',
-        'ReasoningMessageEnd',
-        'ReasoningMessageChunk',
-    ],
-};
-/**
- * Default message roles
- */
-export const MESSAGE_ROLES = {
-    DEVELOPER: 'developer',
-    SYSTEM: 'system',
-    ASSISTANT: 'assistant',
-    USER: 'user',
-    TOOL: 'tool',
-};
-/**
- * Run outcome types
- */
-export const RUN_OUTCOMES = {
-    SUCCESS: 'success',
-    INTERRUPT: 'interrupt',
-};

package/dist/src/ag-ui/ag-ui-event-mapper.d.ts

@@ -1,88 +0,0 @@
-import { oCapabilityType } from '../capabilities/enums/o-capability.type-enum.js';
-import { oCapabilityResult } from '../capabilities/o-capability.result.js';
-import { oIntent } from '../intent/o-intent.js';
-import { AGUIEvent, RunStarted, RunFinished, RunError, StepStarted, StepFinished, StateSnapshot, StateDelta, ActivitySnapshot } from './types/ag-ui-event.types.js';
-import { AGUIEventContext, AGUIEventMappingConfig } from './types/ag-ui-config.interface.js';
-/**
- * Maps oLane execution events to AG-UI protocol events
- */
-export declare class AGUIEventMapper {
-    private config;
-    private context;
-    constructor(context: AGUIEventContext, config?: Partial<AGUIEventMappingConfig>);
-    /**
-     * Map lane creation to RunStarted event
-     */
-    mapLaneStartToRunStarted(intent: oIntent, input?: unknown): RunStarted;
-    /**
-     * Map lane completion to RunFinished event
-     */
-    mapLaneCompleteToRunFinished(result: oCapabilityResult): RunFinished;
-    /**
-     * Map lane error to RunError event
-     */
-    mapLaneErrorToRunError(error: Error | string): RunError;
-    /**
-     * Map capability execution start to StepStarted event
-     */
-    mapCapabilityStartToStepStarted(capabilityType: oCapabilityType): StepStarted;
-    /**
-     * Map capability execution end to StepFinished event
-     */
-    mapCapabilityEndToStepFinished(capabilityType: oCapabilityType): StepFinished;
-    /**
-     * Map capability result to appropriate AG-UI events
-     * This is the core mapping logic that handles different capability types
-     */
-    mapCapabilityToEvents(result: oCapabilityResult, cycleNumber: number): AGUIEvent[];
-    /**
-     * Map EVALUATE capability to text message events (agent reasoning)
-     */
-    private mapEvaluateCapability;
-    /**
-     * Map TASK capability to tool call events
-     */
-    private mapTaskCapability;
-    /**
-     * Map SEARCH capability to activity events
-     */
-    private mapSearchCapability;
-    /**
-     * Map CONFIGURE capability to activity events
-     */
-    private mapConfigureCapability;
-    /**
-     * Map MULTIPLE_STEP capability to activity events
-     */
-    private mapMultipleStepCapability;
-    /**
-     * Map ERROR capability to activity events
-     */
-    private mapErrorCapability;
-    /**
-     * Map unknown capability to custom event
-     */
-    private mapUnknownCapability;
-    /**
-     * Map execution sequence to state snapshot
-     */
-    mapSequenceToStateSnapshot(sequence: oCapabilityResult[]): StateSnapshot;
-    /**
-     * Map execution sequence update to state delta
-     */
-    mapSequenceToStateDelta(oldSequence: oCapabilityResult[], newSequence: oCapabilityResult[]): StateDelta | null;
-    /**
-     * Map streaming chunk to activity event
-     * Extracts capability result from oResponse wrapper and maps appropriately
-     */
-    mapChunkToActivity(chunk: any, cycleNumber: number): ActivitySnapshot;
-    /**
-     * Update the event context
-     */
-    updateContext(updates: Partial<AGUIEventContext>): void;
-    /**
-     * Get current context
-     */
-    getContext(): AGUIEventContext;
-}
-//# sourceMappingURL=ag-ui-event-mapper.d.ts.map

package/dist/src/ag-ui/ag-ui-event-mapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ag-ui-event-mapper.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/ag-ui-event-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iDAAiD,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EACL,SAAS,EACT,UAAU,EACV,WAAW,EACX,QAAQ,EACR,WAAW,EACX,YAAY,EAQZ,aAAa,EACb,UAAU,EACV,gBAAgB,EAEjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mCAAmC,CAAC;AAY3C;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,OAAO,CAAmB;gBAGhC,OAAO,EAAE,gBAAgB,EACzB,MAAM,GAAE,OAAO,CAAC,sBAAsB,CAAM;IAgB9C;;OAEG;IACH,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,UAAU;IAWtE;;OAEG;IACH,4BAA4B,CAAC,MAAM,EAAE,iBAAiB,GAAG,WAAW;IAWpE;;OAEG;IACH,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ;IAavD;;OAEG;IACH,+BAA+B,CAC7B,cAAc,EAAE,eAAe,GAC9B,WAAW;IAQd;;OAEG;IACH,8BAA8B,CAC5B,cAAc,EAAE,eAAe,GAC9B,YAAY;IAQf;;;OAGG;IACH,qBAAqB,CACnB,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,MAAM,GAClB,SAAS,EAAE;IA0Cd;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkE7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8DzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA0B3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA0B9B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA0BjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsB1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACH,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,aAAa;IAgBxE;;OAEG;IACH,uBAAuB,CACrB,WAAW,EAAE,iBAAiB,EAAE,EAChC,WAAW,EAAE,iBAAiB,EAAE,GAC/B,UAAU,GAAG,IAAI;IAkCpB;;;OAGG;IACH,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,gBAAgB;IA8GrE;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAIvD;;OAEG;IACH,UAAU,IAAI,gBAAgB;CAG/B"}

package/dist/src/ag-ui/ag-ui-event-mapper.js

@@ -1,487 +0,0 @@
-import { oCapabilityType } from '../capabilities/enums/o-capability.type-enum.js';
-import { generateMessageId, generateToolCallId, generateTimestamp, generateJSONPatch, chunkString, capabilityTypeToStepName, safeJSONStringify, } from './ag-ui-utils.js';
-import { AG_UI_DEFAULTS, ACTIVITY_TYPES } from './ag-ui-constants.js';
-/**
- * Maps oLane execution events to AG-UI protocol events
- */
-export class AGUIEventMapper {
-    constructor(context, config = {}) {
-        this.context = context;
-        this.config = {
-            includeRawEvents: config.includeRawEvents ?? AG_UI_DEFAULTS.INCLUDE_RAW_EVENTS,
-            emitActivityEvents: config.emitActivityEvents ?? AG_UI_DEFAULTS.EMIT_ACTIVITY_EVENTS,
-            emitReasoningEvents: config.emitReasoningEvents ?? AG_UI_DEFAULTS.EMIT_REASONING_EVENTS,
-            textChunkSize: config.textChunkSize ?? AG_UI_DEFAULTS.TEXT_CHUNK_SIZE,
-            autoGenerateThreadId: config.autoGenerateThreadId ?? AG_UI_DEFAULTS.AUTO_GENERATE_THREAD_ID,
-        };
-    }
-    /**
-     * Map lane creation to RunStarted event
-     */
-    mapLaneStartToRunStarted(intent, input) {
-        return {
-            type: 'RunStarted',
-            threadId: this.context.threadId,
-            runId: this.context.runId,
-            parentRunId: this.context.parentRunId,
-            input: input || { intent: intent.value },
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map lane completion to RunFinished event
-     */
-    mapLaneCompleteToRunFinished(result) {
-        return {
-            type: 'RunFinished',
-            threadId: this.context.threadId,
-            runId: this.context.runId,
-            result: result.result,
-            outcome: 'success',
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map lane error to RunError event
-     */
-    mapLaneErrorToRunError(error) {
-        const message = typeof error === 'string' ? error : error.message;
-        return {
-            type: 'RunError',
-            message,
-            code: typeof error === 'object' && 'code' in error
-                ? error.code
-                : undefined,
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map capability execution start to StepStarted event
-     */
-    mapCapabilityStartToStepStarted(capabilityType) {
-        return {
-            type: 'StepStarted',
-            stepName: capabilityTypeToStepName(capabilityType),
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map capability execution end to StepFinished event
-     */
-    mapCapabilityEndToStepFinished(capabilityType) {
-        return {
-            type: 'StepFinished',
-            stepName: capabilityTypeToStepName(capabilityType),
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map capability result to appropriate AG-UI events
-     * This is the core mapping logic that handles different capability types
-     */
-    mapCapabilityToEvents(result, cycleNumber) {
-        const events = [];
-        // Map based on capability type
-        switch (result.type) {
-            case oCapabilityType.EVALUATE:
-                events.push(...this.mapEvaluateCapability(result, cycleNumber));
-                break;
-            case oCapabilityType.TASK:
-                events.push(...this.mapTaskCapability(result, cycleNumber));
-                break;
-            case oCapabilityType.SEARCH:
-                events.push(...this.mapSearchCapability(result, cycleNumber));
-                break;
-            case oCapabilityType.CONFIGURE:
-                events.push(...this.mapConfigureCapability(result, cycleNumber));
-                break;
-            case oCapabilityType.MULTIPLE_STEP:
-                events.push(...this.mapMultipleStepCapability(result, cycleNumber));
-                break;
-            case oCapabilityType.ERROR:
-                events.push(...this.mapErrorCapability(result, cycleNumber));
-                break;
-            case oCapabilityType.STOP:
-                // STOP doesn't generate events - it's handled at the lane level
-                break;
-            default:
-                // Unknown capability type - emit as custom event
-                events.push(this.mapUnknownCapability(result, cycleNumber));
-                break;
-        }
-        return events;
-    }
-    /**
-     * Map EVALUATE capability to text message events (agent reasoning)
-     */
-    mapEvaluateCapability(result, cycleNumber) {
-        const events = [];
-        const messageId = generateMessageId();
-        // Store message ID for this cycle
-        if (!this.context.cycleToMessageId) {
-            this.context.cycleToMessageId = new Map();
-        }
-        this.context.cycleToMessageId.set(cycleNumber, messageId);
-        this.context.currentMessageId = messageId;
-        // Start message
-        events.push({
-            type: 'TextMessageStart',
-            messageId,
-            role: 'assistant',
-            timestamp: generateTimestamp(),
-        });
-        // Extract reasoning/summary from result
-        const reasoning = result.config?.params?.reasoning ||
-            result.config?.params?.summary ||
-            result.result?.reasoning ||
-            result.result?.summary ||
-            'Evaluating next steps...';
-        const content = typeof reasoning === 'string' ? reasoning : safeJSONStringify(reasoning);
-        // Chunk the content for streaming effect
-        if (this.config.textChunkSize &&
-            content.length > this.config.textChunkSize) {
-            const chunks = chunkString(content, this.config.textChunkSize);
-            for (const chunk of chunks) {
-                events.push({
-                    type: 'TextMessageContent',
-                    messageId,
-                    delta: chunk,
-                    timestamp: generateTimestamp(),
-                });
-            }
-        }
-        else {
-            events.push({
-                type: 'TextMessageContent',
-                messageId,
-                delta: content,
-                timestamp: generateTimestamp(),
-            });
-        }
-        // End message
-        events.push({
-            type: 'TextMessageEnd',
-            messageId,
-            timestamp: generateTimestamp(),
-        });
-        return events;
-    }
-    /**
-     * Map TASK capability to tool call events
-     */
-    mapTaskCapability(result, cycleNumber) {
-        const events = [];
-        const toolCallId = generateToolCallId();
-        const messageId = this.context.currentMessageId || generateMessageId();
-        // Store tool call ID
-        if (!this.context.taskToToolCallId) {
-            this.context.taskToToolCallId = new Map();
-        }
-        this.context.taskToToolCallId.set(`cycle-${cycleNumber}`, toolCallId);
-        this.context.currentToolCallId = toolCallId;
-        // Extract tool information
-        const toolName = result.config?.params?.task?.address ||
-            result.config?.params?.tool ||
-            'task';
-        // Tool call start
-        events.push({
-            type: 'ToolCallStart',
-            toolCallId,
-            toolCallName: String(toolName),
-            parentMessageId: messageId,
-            timestamp: generateTimestamp(),
-        });
-        // Tool call arguments
-        const args = result.config?.params?.task?.payload || result.config?.params || {};
-        const argsStr = safeJSONStringify(args);
-        events.push({
-            type: 'ToolCallArgs',
-            toolCallId,
-            delta: argsStr,
-            timestamp: generateTimestamp(),
-        });
-        // Tool call end
-        events.push({
-            type: 'ToolCallEnd',
-            toolCallId,
-            timestamp: generateTimestamp(),
-        });
-        // Tool call result
-        events.push({
-            type: 'ToolCallResult',
-            messageId,
-            toolCallId,
-            content: result.result || result.error || null,
-            role: 'tool',
-            timestamp: generateTimestamp(),
-        });
-        return events;
-    }
-    /**
-     * Map SEARCH capability to activity events
-     */
-    mapSearchCapability(result, cycleNumber) {
-        if (!this.config.emitActivityEvents) {
-            return [];
-        }
-        const messageId = generateMessageId();
-        return [
-            {
-                type: 'ActivitySnapshot',
-                messageId,
-                activityType: ACTIVITY_TYPES.SEARCH,
-                content: {
-                    cycle: cycleNumber,
-                    query: result.config?.params?.query || 'searching...',
-                    results: result.result,
-                },
-                replace: true,
-                timestamp: generateTimestamp(),
-            },
-        ];
-    }
-    /**
-     * Map CONFIGURE capability to activity events
-     */
-    mapConfigureCapability(result, cycleNumber) {
-        if (!this.config.emitActivityEvents) {
-            return [];
-        }
-        const messageId = generateMessageId();
-        return [
-            {
-                type: 'ActivitySnapshot',
-                messageId,
-                activityType: ACTIVITY_TYPES.CONFIGURE,
-                content: {
-                    cycle: cycleNumber,
-                    configuration: result.config?.params || {},
-                    status: result.error ? 'failed' : 'completed',
-                },
-                replace: true,
-                timestamp: generateTimestamp(),
-            },
-        ];
-    }
-    /**
-     * Map MULTIPLE_STEP capability to activity events
-     */
-    mapMultipleStepCapability(result, cycleNumber) {
-        if (!this.config.emitActivityEvents) {
-            return [];
-        }
-        const messageId = generateMessageId();
-        return [
-            {
-                type: 'ActivitySnapshot',
-                messageId,
-                activityType: ACTIVITY_TYPES.PLAN,
-                content: {
-                    cycle: cycleNumber,
-                    steps: result.result?.steps || [],
-                    currentStep: result.result?.currentStep || 0,
-                },
-                replace: true,
-                timestamp: generateTimestamp(),
-            },
-        ];
-    }
-    /**
-     * Map ERROR capability to activity events
-     */
-    mapErrorCapability(result, cycleNumber) {
-        const messageId = generateMessageId();
-        return [
-            {
-                type: 'ActivitySnapshot',
-                messageId,
-                activityType: ACTIVITY_TYPES.ERROR,
-                content: {
-                    cycle: cycleNumber,
-                    error: result.error || 'Unknown error',
-                    recovery: result.result || 'Attempting recovery...',
-                },
-                replace: true,
-                timestamp: generateTimestamp(),
-            },
-        ];
-    }
-    /**
-     * Map unknown capability to custom event
-     */
-    mapUnknownCapability(result, cycleNumber) {
-        return {
-            type: 'Custom',
-            name: `capability_${result.type}`,
-            value: {
-                cycle: cycleNumber,
-                result: result.result,
-                error: result.error,
-            },
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map execution sequence to state snapshot
-     */
-    mapSequenceToStateSnapshot(sequence) {
-        return {
-            type: 'StateSnapshot',
-            snapshot: {
-                sequence: sequence.map((s) => ({
-                    type: s.type,
-                    result: s.result,
-                    error: s.error,
-                    id: s.id,
-                })),
-                cycleCount: sequence.length,
-            },
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map execution sequence update to state delta
-     */
-    mapSequenceToStateDelta(oldSequence, newSequence) {
-        const oldState = {
-            sequence: oldSequence.map((s) => ({
-                type: s.type,
-                result: s.result,
-                error: s.error,
-                id: s.id,
-            })),
-            cycleCount: oldSequence.length,
-        };
-        const newState = {
-            sequence: newSequence.map((s) => ({
-                type: s.type,
-                result: s.result,
-                error: s.error,
-                id: s.id,
-            })),
-            cycleCount: newSequence.length,
-        };
-        const delta = generateJSONPatch(oldState, newState);
-        if (delta.length === 0) {
-            return null;
-        }
-        return {
-            type: 'StateDelta',
-            delta,
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Map streaming chunk to activity event
-     * Extracts capability result from oResponse wrapper and maps appropriately
-     */
-    mapChunkToActivity(chunk, cycleNumber) {
-        const messageId = generateMessageId();
-        // Extract capability result from oResponse wrapper
-        // Structure: { data: { id, result, humanResult, type, error, ... }, _last, _isStreaming, ... }
-        const capabilityData = chunk.data || chunk;
-        const capabilityType = capabilityData.type;
-        const result = capabilityData.result;
-        const humanResult = capabilityData.humanResult;
-        const error = capabilityData.error;
-        // Determine activity type based on capability type
-        let activityType;
-        let content;
-        switch (capabilityType) {
-            case oCapabilityType.EVALUATE:
-                activityType = ACTIVITY_TYPES.EVALUATE;
-                content = {
-                    cycle: cycleNumber,
-                    reasoning: result?.reasoning || result?.summary || humanResult,
-                    status: error ? 'error' : 'evaluating',
-                };
-                break;
-            case oCapabilityType.TASK:
-                activityType = ACTIVITY_TYPES.EXECUTE;
-                content = {
-                    cycle: cycleNumber,
-                    task: result?.task?.address || result?.tool || 'task',
-                    status: error ? 'error' : 'executing',
-                    result: humanResult || result,
-                };
-                break;
-            case oCapabilityType.SEARCH:
-                activityType = ACTIVITY_TYPES.SEARCH;
-                content = {
-                    cycle: cycleNumber,
-                    query: result?.query || 'searching',
-                    results: result?.results || result,
-                    status: error ? 'error' : 'searching',
-                };
-                break;
-            case oCapabilityType.CONFIGURE:
-                activityType = ACTIVITY_TYPES.CONFIGURE;
-                content = {
-                    cycle: cycleNumber,
-                    configuration: result,
-                    status: error ? 'error' : 'configuring',
-                };
-                break;
-            case oCapabilityType.ERROR:
-                activityType = ACTIVITY_TYPES.ERROR;
-                content = {
-                    cycle: cycleNumber,
-                    error: error || result?.error || 'Unknown error',
-                    recovery: result?.recovery || result?.message,
-                    status: 'error',
-                };
-                break;
-            case oCapabilityType.MULTIPLE_STEP:
-                activityType = ACTIVITY_TYPES.PLAN;
-                content = {
-                    cycle: cycleNumber,
-                    steps: result?.steps || [],
-                    currentStep: result?.currentStep || 0,
-                    status: error ? 'error' : 'planning',
-                };
-                break;
-            case oCapabilityType.STOP:
-                activityType = ACTIVITY_TYPES.EXECUTE;
-                content = {
-                    cycle: cycleNumber,
-                    status: 'completed',
-                    result: humanResult || result,
-                };
-                break;
-            default:
-                // Unknown capability type - provide generic progress
-                activityType = ACTIVITY_TYPES.PROGRESS;
-                content = {
-                    cycle: cycleNumber,
-                    type: capabilityType,
-                    result: humanResult || result,
-                    status: error ? 'error' : 'processing',
-                };
-                break;
-        }
-        // Add error details if present
-        if (error) {
-            content.error = error;
-        }
-        return {
-            type: 'ActivitySnapshot',
-            messageId,
-            activityType,
-            content,
-            replace: false, // Don't replace - show progress updates
-            timestamp: generateTimestamp(),
-        };
-    }
-    /**
-     * Update the event context
-     */
-    updateContext(updates) {
-        Object.assign(this.context, updates);
-    }
-    /**
-     * Get current context
-     */
-    getContext() {
-        return { ...this.context };
-    }
-}