@crewx/sdk 0.8.0-rc.58

package/dist/types/layout.types.d.ts

@@ -0,0 +1,115 @@
+import type { TemplateVars } from './template.types';
+export interface PropSchema {
+    type: 'string' | 'number' | 'bool' | 'array' | 'arrayOf' | 'object' | 'shape' | 'oneOfType' | 'func' | 'node';
+    isRequired?: boolean;
+    defaultValue?: any;
+    oneOf?: any[];
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    itemType?: string;
+    itemOneOf?: any[];
+    shape?: Record<string, PropSchema>;
+    types?: string[];
+    pattern?: string;
+    description?: string;
+}
+export interface LayoutDefinition {
+    id: string;
+    version: string;
+    description: string;
+    template: string;
+    propsSchema: Record<string, PropSchema>;
+    defaultProps: Record<string, any>;
+}
+export interface CustomLayoutDefinition {
+    template: string;
+    description?: string;
+    version?: string;
+    propsSchema?: Record<string, any>;
+    defaultProps?: Record<string, any>;
+}
+export type InlineLayoutSpec = string | {
+    id: string;
+    props?: Record<string, any>;
+};
+export interface ValidationResult {
+    valid: boolean;
+    props: Record<string, any>;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    value?: any;
+}
+export interface LoaderOptions {
+    templatesPath: string;
+    validationMode?: 'strict' | 'lenient';
+    fallbackLayoutId?: string;
+}
+export interface RenderContext {
+    user_input?: string;
+    messages?: Array<{
+        text: string;
+        isAssistant: boolean;
+        metadata?: Record<string, any>;
+    }>;
+    mode?: 'query' | 'execute';
+    platform?: string;
+    metadata?: Record<string, any>;
+    env?: Record<string, any>;
+    tools?: {
+        list?: Array<Record<string, any>>;
+        json?: string;
+        count?: number;
+        [key: string]: any;
+    } | null;
+    vars: TemplateVars;
+    agent: {
+        id: string;
+        name: string;
+        provider?: string;
+        model?: string;
+        workingDirectory?: string;
+        inline: {
+            prompt: string;
+            [key: string]: any;
+        };
+        specialties?: string[];
+        capabilities?: string[];
+        description?: string;
+        [key: string]: any;
+    };
+    documents: Record<string, {
+        content: string;
+        toc?: string;
+        summary?: string;
+        path?: string;
+    }>;
+    props: Record<string, any>;
+    session?: {
+        options?: string[];
+        [key: string]: any;
+    };
+    context?: Record<string, any>;
+}
+export interface RawLayoutYaml {
+    id?: string;
+    version?: string;
+    description?: string;
+    propsSchema?: Record<string, any>;
+    template?: string;
+    layouts?: Record<string, string>;
+}
+export declare class LayoutLoadError extends Error {
+    readonly layoutId?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, layoutId?: string | undefined, cause?: Error | undefined);
+}
+export declare class PropsValidationError extends Error {
+    readonly errors: ValidationError[];
+    readonly cause?: Error | undefined;
+    constructor(message: string, errors?: ValidationError[], cause?: Error | undefined);
+}

package/dist/types/layout.types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropsValidationError = exports.LayoutLoadError = void 0;
+class LayoutLoadError extends Error {
+    constructor(message, layoutId, cause) {
+        super(message);
+        this.layoutId = layoutId;
+        this.cause = cause;
+        this.name = 'LayoutLoadError';
+    }
+}
+exports.LayoutLoadError = LayoutLoadError;
+class PropsValidationError extends Error {
+    constructor(message, errors = [], cause) {
+        super(message);
+        this.errors = errors;
+        this.cause = cause;
+        this.name = 'PropsValidationError';
+    }
+}
+exports.PropsValidationError = PropsValidationError;
+//# sourceMappingURL=layout.types.js.map

package/dist/types/layout.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.types.js","sourceRoot":"","sources":["../../src/types/layout.types.ts"],"names":[],"mappings":";;;AAmMA,MAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAe,EAAkB,QAAiB,EAAkB,KAAa;QAC3F,KAAK,CAAC,OAAO,CAAC,CAAC;QAD4B,aAAQ,GAAR,QAAQ,CAAS;QAAkB,UAAK,GAAL,KAAK,CAAQ;QAE3F,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AALD,0CAKC;AAKD,MAAa,oBAAqB,SAAQ,KAAK;IAC7C,YACE,OAAe,EACC,SAA4B,EAAE,EAC9B,KAAa;QAE7B,KAAK,CAAC,OAAO,CAAC,CAAC;QAHC,WAAM,GAAN,MAAM,CAAwB;QAC9B,UAAK,GAAL,KAAK,CAAQ;QAG7B,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AATD,oDASC"}

package/dist/types/provider.types.d.ts

@@ -0,0 +1,12 @@
+import type { AIProvider } from '../core/providers/ai-provider.interface';
+export interface ProviderConfig {
+    namespace: string;
+    id: string;
+    apiKey?: string;
+    model?: string;
+}
+export type ProviderInput = ProviderConfig | AIProvider | undefined;
+export interface ProviderResolutionResult {
+    provider: AIProvider;
+    defaultModel?: string;
+}

package/dist/types/provider.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=provider.types.js.map

package/dist/types/provider.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.types.js","sourceRoot":"","sources":["../../src/types/provider.types.ts"],"names":[],"mappings":""}

package/dist/types/skill-runtime.types.d.ts

@@ -0,0 +1,244 @@
+import { SkillMetadata, SkillContent, SkillDefinition, SkillValidationError as SkillValidationDetail, SkillValidationResult } from '../schema/skills.types';
+import { AgentDefinition } from '../schema/skills.types';
+export type SkillRuntimeStage = 'load' | 'validate' | 'prepare' | 'execute' | 'cleanup';
+export interface SkillLoadOptions {
+    validationMode?: 'strict' | 'lenient';
+    loadContent?: boolean;
+    resolveDependencies?: boolean;
+    searchPaths?: string[];
+    cache?: boolean;
+    filters?: {
+        include?: string[];
+        exclude?: string[];
+    };
+}
+export interface SkillExecutionContext {
+    skillName: string;
+    skillVersion: string;
+    workingDirectory: string;
+    environment: Record<string, string>;
+    timeout: number;
+    runtimeRequirements: {
+        python?: string;
+        node?: string;
+        docker?: boolean;
+        memory?: string;
+        [key: string]: string | boolean | undefined;
+    };
+    configuration: {
+        metadata: SkillMetadata;
+        content?: SkillContent;
+        agentConfig: AgentDefinition;
+    };
+    options: {
+        validationMode: 'strict' | 'lenient';
+        progressiveLoading: boolean;
+        cacheEnabled: boolean;
+    };
+    executionId: string;
+    startTime: Date;
+}
+export interface SDKExecutionContext extends SkillExecutionContext {
+    services: {
+        layoutLoader?: any;
+        templateContext?: any;
+        agentFactory?: any;
+    };
+}
+export interface CLIExecutionContext extends SkillExecutionContext {
+    cliOptions: {
+        verbose?: boolean;
+        dryRun?: boolean;
+        debugMode?: boolean;
+        interactive?: boolean;
+    };
+    terminal: {
+        width: number;
+        height: number;
+        interactive: boolean;
+    };
+}
+export interface SkillExecutionResult {
+    success: boolean;
+    output?: string;
+    error?: Error;
+    metadata: {
+        executionId: string;
+        executionTime: number;
+        memoryUsage?: number;
+        dependenciesUsed: string[];
+        cacheHits: number;
+        cacheMisses: number;
+    };
+    artifacts?: {
+        type: 'file' | 'directory' | 'url';
+        path: string;
+        description?: string;
+    }[];
+}
+export interface IProgressiveSkillLoader {
+    loadMetadata(skillPaths: string[]): Promise<SkillMetadata[]>;
+    loadFullContent(skillName: string): Promise<SkillDefinition>;
+    isFullyLoaded(skillName: string): boolean;
+    preloadContent(skillNames: string[]): Promise<void>;
+    clearContentCache(): Promise<void>;
+}
+export interface SkillCacheStats {
+    metadataCache: {
+        count: number;
+        size: number;
+        hitRate: number;
+    };
+    contentCache: {
+        count: number;
+        size: number;
+        hitRate: number;
+    };
+    total: {
+        size: number;
+        hitRate: number;
+    };
+}
+export interface ISkillRuntime {
+    loadSkills(options?: SkillLoadOptions): Promise<SkillMetadata[]>;
+    validateSkill(skillName: string): Promise<SkillValidationResult>;
+    prepareContext(skillName: string, agentConfig: AgentDefinition, options?: Partial<SkillExecutionContext>): Promise<SkillExecutionContext>;
+    executeSkill(context: SkillExecutionContext, input: string): Promise<SkillExecutionResult>;
+    cleanup(context: SkillExecutionContext): Promise<void>;
+    listAvailableSkills(): Promise<string[]>;
+    getSkillMetadata(skillName: string): Promise<SkillMetadata | null>;
+    getSkillDefinition(skillName: string): Promise<SkillDefinition | null>;
+    resolveDependencies(skillName: string): Promise<SkillResolutionResult>;
+    clearCache(): Promise<void>;
+    getCacheStats(): SkillCacheStats;
+    getRuntimeInfo(): SkillRuntimeInfo;
+    shutdown(): Promise<void>;
+}
+export interface SkillResolutionResult {
+    name: string;
+    definition: SkillDefinition;
+    dependencies: SkillResolutionResult[];
+    sourcePath: string;
+    metadata: {
+        resolvedAt: Date;
+        version: string;
+        dependenciesCount: number;
+    };
+}
+export interface SkillRuntimeInfo {
+    version: string;
+    startTime: Date;
+    skillsLoaded: number;
+    uptime: number;
+    memoryUsage: {
+        rss: number;
+        heapUsed: number;
+        heapTotal: number;
+    };
+}
+export interface IClaudeSkillAdapter {
+    extractMetadata(skillFilePath: string): Promise<SkillMetadata>;
+    parseContent(fullContent: string): SkillContent;
+    mapToCrewXAgent(skill: SkillDefinition): AgentDefinition;
+    validateSkillFile(filePath: string): Promise<SkillValidationResult>;
+    discoverSkills(directory: string): Promise<string[]>;
+}
+export interface SkillExecutionErrorDetails {
+    stage: SkillRuntimeStage;
+    skillName: string;
+    executionId?: string;
+    error: Error;
+    recoverable: boolean;
+    suggestions: string[];
+    timestamp: Date;
+}
+export interface SkillRuntimeEvents {
+    'skill:loaded': {
+        skillName: string;
+        metadata: SkillMetadata;
+    };
+    'skill:validated': {
+        skillName: string;
+        result: SkillValidationResult;
+    };
+    'skill:executed': {
+        skillName: string;
+        result: SkillExecutionResult;
+    };
+    'skill:error': {
+        error: SkillExecutionErrorDetails;
+    };
+    'cache:cleared': {};
+    'runtime:shutdown': {};
+}
+export interface ProgressiveDisclosureConfig {
+    enabled: boolean;
+    metadataCacheTTL: number;
+    contentCacheTTL: number;
+    maxPreloadSkills: number;
+    preloadStrategy: 'recent' | 'popular' | 'dependency' | 'none';
+    contentLoadThreshold: number;
+}
+export interface RuntimeRequirementsValidator {
+    validatePython(requirement: string): Promise<boolean>;
+    validateNode(requirement: string): Promise<boolean>;
+    validateDocker(): Promise<boolean>;
+    validateMemory(requirement: string): Promise<boolean>;
+    getCurrentRuntime(): Promise<RuntimeInfo>;
+}
+export interface RuntimeInfo {
+    python?: {
+        version: string;
+        available: boolean;
+    };
+    node?: {
+        version: string;
+        available: boolean;
+    };
+    docker?: {
+        version: string;
+        available: boolean;
+    };
+    memory: {
+        total: number;
+        available: number;
+    };
+}
+export interface SkillBundleInfo {
+    id: string;
+    version: string;
+    skills: string[];
+    metadata: {
+        name: string;
+        description: string;
+        author?: string;
+        createdAt: Date;
+        size: number;
+    };
+    runtimeRequirements: {
+        python?: string;
+        node?: string;
+        docker?: boolean;
+        [key: string]: string | boolean | undefined;
+    };
+}
+export declare class SkillRuntimeError extends Error {
+    readonly stage: SkillRuntimeStage;
+    readonly skillName?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, stage: SkillRuntimeStage, skillName?: string | undefined, cause?: Error | undefined);
+}
+export declare class ProgressiveLoadingError extends SkillRuntimeError {
+    constructor(message: string, skillName?: string, cause?: Error);
+}
+export declare class SkillValidationError extends SkillRuntimeError {
+    readonly validationErrors: SkillValidationDetail[];
+    constructor(message: string, validationErrors: SkillValidationDetail[], skillName?: string);
+}
+export declare class SkillExecutionError extends SkillRuntimeError {
+    readonly executionId: string;
+    constructor(message: string, skillName: string, executionId: string, cause?: Error);
+}
+export declare class SkillContextError extends SkillRuntimeError {
+    constructor(message: string, skillName?: string, cause?: Error);
+}

package/dist/types/skill-runtime.types.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillContextError = exports.SkillExecutionError = exports.SkillValidationError = exports.ProgressiveLoadingError = exports.SkillRuntimeError = void 0;
+class SkillRuntimeError extends Error {
+    constructor(message, stage, skillName, cause) {
+        super(message);
+        this.stage = stage;
+        this.skillName = skillName;
+        this.cause = cause;
+        this.name = 'SkillRuntimeError';
+    }
+}
+exports.SkillRuntimeError = SkillRuntimeError;
+class ProgressiveLoadingError extends SkillRuntimeError {
+    constructor(message, skillName, cause) {
+        super(message, 'load', skillName, cause);
+        this.name = 'ProgressiveLoadingError';
+    }
+}
+exports.ProgressiveLoadingError = ProgressiveLoadingError;
+class SkillValidationError extends SkillRuntimeError {
+    constructor(message, validationErrors, skillName) {
+        super(message, 'validate', skillName);
+        this.validationErrors = validationErrors;
+        this.name = 'SkillValidationError';
+    }
+}
+exports.SkillValidationError = SkillValidationError;
+class SkillExecutionError extends SkillRuntimeError {
+    constructor(message, skillName, executionId, cause) {
+        super(message, 'execute', skillName, cause);
+        this.executionId = executionId;
+        this.name = 'SkillExecutionError';
+    }
+}
+exports.SkillExecutionError = SkillExecutionError;
+class SkillContextError extends SkillRuntimeError {
+    constructor(message, skillName, cause) {
+        super(message, 'prepare', skillName, cause);
+        this.name = 'SkillContextError';
+    }
+}
+exports.SkillContextError = SkillContextError;
+//# sourceMappingURL=skill-runtime.types.js.map

package/dist/types/skill-runtime.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-runtime.types.js","sourceRoot":"","sources":["../../src/types/skill-runtime.types.ts"],"names":[],"mappings":";;;AA4YA,MAAa,iBAAkB,SAAQ,KAAK;IAC1C,YACE,OAAe,EACC,KAAwB,EACxB,SAAkB,EAClB,KAAa;QAE7B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,UAAK,GAAL,KAAK,CAAmB;QACxB,cAAS,GAAT,SAAS,CAAS;QAClB,UAAK,GAAL,KAAK,CAAQ;QAG7B,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AAVD,8CAUC;AAED,MAAa,uBAAwB,SAAQ,iBAAiB;IAC5D,YAAY,OAAe,EAAE,SAAkB,EAAE,KAAa;QAC5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AALD,0DAKC;AAED,MAAa,oBAAqB,SAAQ,iBAAiB;IACzD,YACE,OAAe,EACC,gBAAyC,EACzD,SAAkB;QAElB,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;QAHtB,qBAAgB,GAAhB,gBAAgB,CAAyB;QAIzD,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AATD,oDASC;AAED,MAAa,mBAAoB,SAAQ,iBAAiB;IACxD,YACE,OAAe,EACf,SAAiB,EACD,WAAmB,EACnC,KAAa;QAEb,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAH5B,gBAAW,GAAX,WAAW,CAAQ;QAInC,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AAVD,kDAUC;AAED,MAAa,iBAAkB,SAAQ,iBAAiB;IACtD,YAAY,OAAe,EAAE,SAAkB,EAAE,KAAa;QAC5D,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC"}

package/dist/types/structured-payload.types.d.ts

@@ -0,0 +1,46 @@
+import { CallStackFrame } from '../core/agent/event-bus';
+export interface StructuredMessage {
+    id: string;
+    userId?: string;
+    text: string;
+    timestamp: string;
+    isAssistant: boolean;
+    metadata?: Record<string, any>;
+}
+export interface AgentInfo {
+    id: string;
+    provider: string;
+    mode: 'query' | 'execute';
+    model?: string;
+}
+export interface StructuredPayloadMetadata {
+    generatedAt: string;
+    messageCount: number;
+    originalContext?: string;
+    platform: string;
+    threadId?: string;
+    callStack?: CallStackFrame[];
+    formattedHistory?: string;
+}
+export interface StructuredPayload {
+    version: string;
+    agent: AgentInfo;
+    prompt: string;
+    context?: string;
+    messages: StructuredMessage[];
+    metadata: StructuredPayloadMetadata;
+}
+export declare function isStructuredPayload(value: unknown): value is StructuredPayload;
+export declare function parseStructuredPayload(input: string | null | undefined): StructuredPayload | null;
+export declare function createStructuredPayload(params: {
+    agentId: string;
+    provider: string;
+    mode: 'query' | 'execute';
+    prompt: string;
+    context?: string;
+    messages?: StructuredMessage[];
+    model?: string;
+    platform?: string;
+    threadId?: string;
+    callStack?: CallStackFrame[];
+}): StructuredPayload;

package/dist/types/structured-payload.types.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStructuredPayload = isStructuredPayload;
+exports.parseStructuredPayload = parseStructuredPayload;
+exports.createStructuredPayload = createStructuredPayload;
+function isStructuredPayload(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const payload = value;
+    return (typeof payload.version === 'string' &&
+        typeof payload.prompt === 'string' &&
+        Array.isArray(payload.messages) &&
+        typeof payload.agent === 'object' &&
+        typeof payload.metadata === 'object' &&
+        typeof payload.agent.id === 'string' &&
+        typeof payload.agent.provider === 'string' &&
+        (payload.agent.mode === 'query' || payload.agent.mode === 'execute'));
+}
+function parseStructuredPayload(input) {
+    if (!input) {
+        return null;
+    }
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (isStructuredPayload(parsed)) {
+            if (!Array.isArray(parsed.messages)) {
+                parsed.messages = [];
+            }
+            return parsed;
+        }
+    }
+    catch (error) {
+    }
+    return null;
+}
+function createStructuredPayload(params) {
+    const now = new Date().toISOString();
+    const messages = params.messages || [];
+    return {
+        version: '1.0',
+        agent: {
+            id: params.agentId,
+            provider: params.provider,
+            mode: params.mode,
+            model: params.model,
+        },
+        prompt: params.prompt,
+        context: params.context,
+        messages,
+        metadata: {
+            generatedAt: now,
+            messageCount: messages.length,
+            originalContext: params.context,
+            platform: params.platform || 'cli',
+            threadId: params.threadId,
+            callStack: params.callStack,
+        },
+    };
+}
+//# sourceMappingURL=structured-payload.types.js.map

package/dist/types/structured-payload.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-payload.types.js","sourceRoot":"","sources":["../../src/types/structured-payload.types.ts"],"names":[],"mappings":";;AA4IA,kDAiBC;AAOD,wDAyBC;AAKD,0DAmCC;AAzFD,SAAgB,mBAAmB,CAAC,KAAc;IAChD,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACxC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,OAAO,GAAG,KAAY,CAAC;IAE7B,OAAO,CACL,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ;QACnC,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ;QAClC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;QAC/B,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ;QACjC,OAAO,OAAO,CAAC,QAAQ,KAAK,QAAQ;QACpC,OAAO,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,QAAQ;QACpC,OAAO,OAAO,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ;QAC1C,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CACrE,CAAC;AACJ,CAAC;AAOD,SAAgB,sBAAsB,CAAC,KAAgC;IACrE,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEnC,IAAI,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC;YAEhC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACpC,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAC;YACvB,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;IAEjB,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAKD,SAAgB,uBAAuB,CAAC,MAWvC;IACC,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACrC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;IAEvC,OAAO;QACL,OAAO,EAAE,KAAK;QACd,KAAK,EAAE;YACL,EAAE,EAAE,MAAM,CAAC,OAAO;YAClB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,KAAK,EAAE,MAAM,CAAC,KAAK;SACpB;QACD,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,QAAQ;QACR,QAAQ,EAAE;YACR,WAAW,EAAE,GAAG;YAChB,YAAY,EAAE,QAAQ,CAAC,MAAM;YAC7B,eAAe,EAAE,MAAM,CAAC,OAAO;YAC/B,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,KAAK;YAClC,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,SAAS,EAAE,MAAM,CAAC,SAAS;SAC5B;KACF,CAAC;AACJ,CAAC"}

package/dist/types/task-log.types.d.ts

@@ -0,0 +1,14 @@
+export type TaskLogEntryType = 'text' | 'tool_use' | 'tool_result' | 'error' | 'info' | 'agent_call';
+export interface TaskLogEntry {
+    timestamp: string;
+    type: TaskLogEntryType;
+    content?: string;
+    toolName?: string;
+    toolInput?: string;
+    toolUseId?: string;
+    resultPreview?: string;
+    isError?: boolean;
+    targetAgent?: string;
+    targetTaskId?: string;
+    errorMessage?: string;
+}

package/dist/types/task-log.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=task-log.types.js.map

package/dist/types/task-log.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-log.types.js","sourceRoot":"","sources":["../../src/types/task-log.types.ts"],"names":[],"mappings":""}

package/dist/types/template.types.d.ts

@@ -0,0 +1,38 @@
+import type { BaseMessage } from '../conversation/conversation-history.interface';
+export interface AgentMetadata {
+    specialties?: string[];
+    capabilities?: string[];
+    description?: string;
+}
+export interface TemplateVars {
+    security_key?: string;
+    [key: string]: unknown;
+}
+export interface BaseContext {
+    user_input?: string;
+    messages?: BaseMessage[];
+    mode?: 'query' | 'execute';
+    platform?: string;
+    env?: Record<string, string | undefined>;
+    tools?: {
+        list: Array<{
+            name: string;
+            description: string;
+            input_schema: any;
+            output_schema?: any;
+        }>;
+        json: string;
+        count: number;
+    };
+    vars?: TemplateVars;
+}
+export interface TemplateContext extends BaseContext {
+    agent?: {
+        id: string;
+        name: string;
+        provider?: string;
+        model?: string;
+        workingDirectory?: string;
+    };
+    agentMetadata?: AgentMetadata;
+}

package/dist/types/template.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=template.types.js.map

package/dist/types/template.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.types.js","sourceRoot":"","sources":["../../src/types/template.types.ts"],"names":[],"mappings":""}

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from './types/agent.types';

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/agent.types"), exports);
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC"}