cognitive-core 0.2.4 → 0.3.1

package/src/runtime/compute-provider.ts

@@ -1,206 +0,0 @@
-import type { AgentBackend, AgentSpawnConfig } from './types.js';
-import type { AnalysisComplexity } from '../workspace/types.js';
-
-// ============================================================
-// Compute Requirements
-// ============================================================
-
-/**
- * Requirements for compute resolution.
- * Templates express preferences; the provider resolves them to concrete backends.
- */
-export interface ComputeRequirements {
-  /** Preferred execution location */
-  mode?: 'local' | 'remote' | 'any';
-  /** Maximum cost budget in cents (for cost-aware routing) */
-  maxCostCents?: number;
-  /** Required agent capabilities */
-  capabilities?: string[];
-  /** Timeout hint (provider may select faster backends for short timeouts) */
-  timeout?: number;
-  /** Complexity hint from template */
-  complexity?: AnalysisComplexity;
-}
-
-// ============================================================
-// Compute Target
-// ============================================================
-
-/**
- * Resolution result: which backend to use and any config overrides.
- */
-export interface ComputeTarget {
-  /** The resolved backend */
-  backend: AgentBackend;
-  /** Config overrides for this resolution (e.g., different timeout, env vars) */
-  overrides?: Partial<AgentSpawnConfig>;
-  /** Source identifier for logging/metrics */
-  source: string;
-}
-
-// ============================================================
-// Compute Source
-// ============================================================
-
-/** Cost tier for routing decisions */
-export type CostTier = 'free' | 'low' | 'medium' | 'high';
-
-/**
- * Registered compute source with metadata.
- */
-export interface ComputeSource {
-  /** Unique name for this source */
-  name: string;
-  /** Underlying backend */
-  backend: AgentBackend;
-  /** Cost tier for routing decisions */
-  costTier: CostTier;
-  /** Execution location */
-  location: 'local' | 'remote';
-  /** Priority (lower = preferred, for tie-breaking) */
-  priority: number;
-}
-
-// ============================================================
-// ComputeProvider Interface
-// ============================================================
-
-/**
- * Resolves agent type + requirements to a concrete compute target.
- *
- * Sits between AgentManager and the raw backend registry.
- * Separates "what agent to run" from "where to run it".
- */
-export interface ComputeProvider {
-  /** Resolve an agent execution request to a backend */
-  resolve(
-    agentType: string,
-    requirements?: ComputeRequirements
-  ): Promise<ComputeTarget>;
-
-  /** Register a compute source */
-  register(source: ComputeSource): void;
-
-  /** Remove a compute source */
-  unregister(name: string): void;
-
-  /** List available compute sources */
-  listSources(): ComputeSource[];
-
-  /** Check if any source supports the given agent type */
-  supports(agentType: string): boolean;
-}
-
-// ============================================================
-// Default Implementation
-// ============================================================
-
-const COST_ORDER: Record<CostTier, number> = {
-  free: 0,
-  low: 1,
-  medium: 5,
-  high: 20,
-};
-
-/**
- * Default compute provider.
- *
- * Resolution strategy:
- * 1. Filter to sources that support the requested agent type
- * 2. Apply mode preference (local/remote) if specified
- * 3. Apply cost budget if specified
- * 4. Check availability in priority order
- * 5. Return first available (or first candidate as fallback)
- */
-export class DefaultComputeProvider implements ComputeProvider {
-  private sources: ComputeSource[] = [];
-
-  register(source: ComputeSource): void {
-    // Remove existing source with same name (re-registration)
-    this.sources = this.sources.filter(s => s.name !== source.name);
-    this.sources.push(source);
-    // Keep sorted by priority (lower = preferred)
-    this.sources.sort((a, b) => a.priority - b.priority);
-  }
-
-  unregister(name: string): void {
-    this.sources = this.sources.filter(s => s.name !== name);
-  }
-
-  listSources(): ComputeSource[] {
-    return [...this.sources];
-  }
-
-  supports(agentType: string): boolean {
-    return this.sources.some(
-      s => s.backend.supportedTypes.includes(agentType)
-    );
-  }
-
-  async resolve(
-    agentType: string,
-    requirements?: ComputeRequirements
-  ): Promise<ComputeTarget> {
-    // Step 1: Filter to sources that support this agent type
-    let candidates = this.sources.filter(
-      s => s.backend.supportedTypes.includes(agentType)
-    );
-
-    if (candidates.length === 0) {
-      // Fallback: try matching by backend name
-      candidates = this.sources.filter(s => s.name === agentType);
-    }
-
-    if (candidates.length === 0) {
-      throw new Error(
-        `No compute source supports agent type '${agentType}'. ` +
-        `Available sources: ${this.sources.map(s => `${s.name}[${s.backend.supportedTypes.join(',')}]`).join(', ') || 'none'}`
-      );
-    }
-
-    // Step 2: Apply mode preference
-    if (requirements?.mode && requirements.mode !== 'any') {
-      const locationFiltered = candidates.filter(
-        s => s.location === requirements.mode
-      );
-      if (locationFiltered.length > 0) {
-        candidates = locationFiltered;
-      }
-      // If no match for preferred mode, fall back to all candidates
-    }
-
-    // Step 3: Apply cost budget
-    if (requirements?.maxCostCents !== undefined) {
-      const budgetFiltered = candidates.filter(
-        s => COST_ORDER[s.costTier] <= requirements.maxCostCents!
-      );
-      if (budgetFiltered.length > 0) {
-        candidates = budgetFiltered;
-      }
-      // If no match within budget, fall back to all candidates
-    }
-
-    // Step 4: Check availability in priority order
-    for (const source of candidates) {
-      if (await source.backend.isAvailable()) {
-        return {
-          backend: source.backend,
-          source: source.name,
-        };
-      }
-    }
-
-    // Step 5: Fallback to first candidate regardless of availability
-    return {
-      backend: candidates[0].backend,
-      source: candidates[0].name,
-    };
-  }
-}
-
-/**
- * Create a DefaultComputeProvider.
- */
-export function createComputeProvider(): DefaultComputeProvider {
-  return new DefaultComputeProvider();
-}

package/src/runtime/flows/learning.ts

@@ -1,166 +0,0 @@
-import type { Task } from '../../types/index.js';
-import type { MemorySystem } from '../../memory/system.js';
-import type {
-  UnifiedLearningPipeline,
-  ImmediateResult,
-  UnifiedBatchResult,
-} from '../../learning/unified-pipeline.js';
-import type { AgentManager } from '../manager.js';
-import type { AgentResult, AgentSession, AgentObserverCallbacks } from '../types.js';
-
-/**
- * Configuration for the learning flow
- */
-export interface LearningFlowConfig {
-  /** Agent type to use for execution */
-  agentType: string;
-  /** Whether to auto-run batch learning when energy threshold is reached */
-  autoBatch?: boolean;
-  /** Observer callbacks for real-time monitoring */
-  observer?: AgentObserverCallbacks;
-}
-
-/**
- * Result of a learning flow execution
- */
-export interface LearningFlowResult {
-  /** The agent result */
-  agentResult: AgentResult;
-  /** Processing result from learning pipeline (immediate phase) */
-  immediateResult: ImmediateResult;
-  /** Batch result if batch learning was triggered (included in immediateResult) */
-  batchResult?: UnifiedBatchResult;
-}
-
-/**
- * Learning Flow
- * Orchestrates: Agent execution → Trajectory capture → Playbook extraction → Memory storage
- *
- * This flow is for the "observation" direction:
- * - Watch agents solve tasks
- * - Extract learning signals from their trajectories
- * - Store playbooks for future guidance
- */
-export class LearningFlow {
-  private manager: AgentManager;
-  private pipeline: UnifiedLearningPipeline;
-  private config: LearningFlowConfig;
-
-  constructor(
-    manager: AgentManager,
-    pipeline: UnifiedLearningPipeline,
-    _memory: MemorySystem,
-    config: LearningFlowConfig
-  ) {
-    this.manager = manager;
-    this.pipeline = pipeline;
-    this.config = {
-      autoBatch: true,
-      ...config,
-    };
-
-    // Register observer if provided
-    if (config.observer) {
-      this.manager.addObserver(config.observer);
-    }
-  }
-
-  /**
-   * Run a single task through the learning flow
-   */
-  async run(task: Task): Promise<LearningFlowResult> {
-    // 1. Spawn agent and get result (WITHOUT knowledge injection for pure learning)
-    const agentResult = await this.manager.spawnBaseline({
-      agentType: this.config.agentType,
-      task,
-      captureToolCalls: true,
-    });
-
-    // 2. Process trajectory through unified pipeline (immediate + optional batch)
-    const immediateResult = await this.pipeline.processTrajectory(
-      agentResult.trajectory
-    );
-
-    return {
-      agentResult,
-      immediateResult,
-      batchResult: immediateResult.batchResult,
-    };
-  }
-
-  /**
-   * Run multiple tasks through the learning flow
-   */
-  async runBatch(tasks: Task[]): Promise<LearningFlowResult[]> {
-    const results: LearningFlowResult[] = [];
-    for (const task of tasks) {
-      const result = await this.run(task);
-      results.push(result);
-    }
-    return results;
-  }
-
-  /**
-   * Observe an external session and learn from it
-   * Use this when another system provides the session
-   */
-  async observeExternal(
-    session: AgentSession,
-    task: Task
-  ): Promise<LearningFlowResult> {
-    // Extract trajectory from session
-    const trajectory = await this.manager.observeAndLearn(session, task);
-
-    // Process through unified pipeline
-    const immediateResult = await this.pipeline.processTrajectory(trajectory);
-
-    return {
-      agentResult: {
-        session,
-        trajectory,
-        success: session.state === 'completed',
-        metrics: {
-          totalTime: session.endTime
-            ? session.endTime.getTime() - session.startTime.getTime()
-            : 0,
-          toolCallCount: session.toolCalls.length,
-          messageCount: session.messages.length,
-        },
-      },
-      immediateResult,
-      batchResult: immediateResult.batchResult,
-    };
-  }
-
-  /**
-   * Force batch learning
-   */
-  async runBatchLearning(): Promise<UnifiedBatchResult> {
-    return this.pipeline.runBatch();
-  }
-
-  /**
-   * Get learning statistics
-   */
-  getStats(): {
-    pendingTrajectories: number;
-    pipelineStats: ReturnType<UnifiedLearningPipeline['getStats']>;
-  } {
-    return {
-      pendingTrajectories: this.pipeline.getAccumulatedCount(),
-      pipelineStats: this.pipeline.getStats(),
-    };
-  }
-}
-
-/**
- * Create a learning flow
- */
-export function createLearningFlow(
-  manager: AgentManager,
-  pipeline: UnifiedLearningPipeline,
-  memory: MemorySystem,
-  config: LearningFlowConfig
-): LearningFlow {
-  return new LearningFlow(manager, pipeline, memory, config);
-}