@cogitator-ai/self-modifying 0.1.0

package/src/meta-reasoning/observation-collector.ts

@@ -0,0 +1,161 @@
+import type {
+  MetaObservation,
+  ReasoningMode,
+  Insight,
+} from '@cogitator-ai/types';
+
+export interface ActionRecord {
+  type: string;
+  toolName?: string;
+  input?: unknown;
+  output?: unknown;
+  error?: string;
+  duration?: number;
+  timestamp: number;
+}
+
+export interface ObservationContext {
+  runId: string;
+  iteration: number;
+  goal: string;
+  currentMode: ReasoningMode;
+  tokensUsed: number;
+  timeElapsed: number;
+  iterationsRemaining: number;
+  budgetRemaining: number;
+}
+
+export class ObservationCollector {
+  private observations = new Map<string, MetaObservation[]>();
+  private actionHistory = new Map<string, ActionRecord[]>();
+  private confidenceHistory = new Map<string, number[]>();
+
+  initializeRun(runId: string): void {
+    this.observations.set(runId, []);
+    this.actionHistory.set(runId, []);
+    this.confidenceHistory.set(runId, []);
+  }
+
+  recordAction(runId: string, action: ActionRecord): void {
+    const history = this.actionHistory.get(runId);
+    if (history) {
+      history.push(action);
+      if (history.length > 100) {
+        history.shift();
+      }
+    }
+  }
+
+  recordConfidence(runId: string, confidence: number): void {
+    const history = this.confidenceHistory.get(runId);
+    if (history) {
+      history.push(confidence);
+      if (history.length > 20) {
+        history.shift();
+      }
+    }
+  }
+
+  collect(
+    context: ObservationContext,
+    insights: Insight[]
+  ): MetaObservation {
+    const { runId, iteration, goal, currentMode } = context;
+    const prevObservations = this.observations.get(runId) ?? [];
+    const lastObs = prevObservations[prevObservations.length - 1];
+    const actions = this.actionHistory.get(runId) ?? [];
+    const confidenceHist = this.confidenceHistory.get(runId) ?? [];
+
+    const currentConfidence = confidenceHist[confidenceHist.length - 1] ?? 0.5;
+    const progressScore = this.calculateProgress(actions);
+    const progressDelta = lastObs ? progressScore - lastObs.progressScore : 0;
+    const stagnationCount = progressDelta < 0.05
+      ? (lastObs?.stagnationCount ?? 0) + 1
+      : 0;
+    const repetitionScore = this.calculateRepetition(actions);
+    const toolSuccessRate = this.calculateToolSuccessRate(actions);
+    const confidenceTrend = this.calculateTrend(confidenceHist);
+
+    const observation: MetaObservation = {
+      runId,
+      iteration,
+      timestamp: Date.now(),
+      progressScore,
+      progressDelta,
+      stagnationCount,
+      currentConfidence,
+      confidenceTrend,
+      confidenceHistory: confidenceHist.slice(-10),
+      tokensUsed: context.tokensUsed,
+      timeElapsed: context.timeElapsed,
+      iterationsRemaining: context.iterationsRemaining,
+      budgetRemaining: context.budgetRemaining,
+      toolSuccessRate,
+      errorRate: 1 - toolSuccessRate,
+      repetitionScore,
+      currentMode,
+      recentActions: actions.slice(-5).map((a) => ({
+        type: a.type,
+        toolName: a.toolName,
+        input: a.input,
+        output: a.output,
+        error: a.error,
+      })),
+      recentInsights: insights.slice(-3),
+      goal,
+    };
+
+    prevObservations.push(observation);
+    return observation;
+  }
+
+  private calculateProgress(actions: ActionRecord[]): number {
+    if (actions.length === 0) return 0;
+    const successful = actions.filter((a) => !a.error).length;
+    return successful / actions.length;
+  }
+
+  private calculateRepetition(actions: ActionRecord[]): number {
+    if (actions.length < 2) return 0;
+    const toolCalls = actions
+      .filter((a) => a.type === 'tool_call' && a.toolName)
+      .map((a) => `${a.toolName}:${JSON.stringify(a.input)}`);
+
+    if (toolCalls.length === 0) return 0;
+    const unique = new Set(toolCalls);
+    return 1 - unique.size / toolCalls.length;
+  }
+
+  private calculateToolSuccessRate(actions: ActionRecord[]): number {
+    const toolCalls = actions.filter((a) => a.type === 'tool_call');
+    if (toolCalls.length === 0) return 1;
+    const successful = toolCalls.filter((a) => !a.error).length;
+    return successful / toolCalls.length;
+  }
+
+  private calculateTrend(values: number[]): 'rising' | 'stable' | 'falling' {
+    if (values.length < 3) return 'stable';
+    const recent = values.slice(-3);
+    const avg = recent.reduce((a, b) => a + b, 0) / recent.length;
+    const first = recent[0];
+
+    if (avg > first + 0.1) return 'rising';
+    if (avg < first - 0.1) return 'falling';
+    return 'stable';
+  }
+
+  getObservations(runId: string): MetaObservation[] {
+    return this.observations.get(runId) ?? [];
+  }
+
+  getLatestObservation(runId: string): MetaObservation | null {
+    const obs = this.observations.get(runId);
+    return obs?.[obs.length - 1] ?? null;
+  }
+
+  cleanupRun(runId: string): void {
+    this.observations.delete(runId);
+    this.actionHistory.delete(runId);
+    this.confidenceHistory.delete(runId);
+  }
+}

package/src/meta-reasoning/prompts.ts

@@ -0,0 +1,131 @@
+import type {
+  MetaObservation,
+  ReasoningMode,
+  ReasoningModeConfig,
+} from '@cogitator-ai/types';
+
+export function buildMetaAssessmentPrompt(
+  observation: MetaObservation,
+  context: {
+    allowedModes: ReasoningMode[];
+    currentModeConfig: ReasoningModeConfig;
+  }
+): string {
+  return `# Meta-Reasoning Assessment
+
+## Current Goal
+${observation.goal}
+
+## Current Reasoning Mode
+Mode: ${observation.currentMode}
+Temperature: ${context.currentModeConfig.temperature}
+Iterations remaining: ${observation.iterationsRemaining}
+
+## Progress Metrics
+- Progress score: ${(observation.progressScore * 100).toFixed(1)}%
+- Progress delta (last step): ${observation.progressDelta > 0 ? '+' : ''}${(observation.progressDelta * 100).toFixed(1)}%
+- Stagnation count: ${observation.stagnationCount} consecutive low-progress iterations
+
+## Confidence Metrics
+- Current confidence: ${(observation.currentConfidence * 100).toFixed(1)}%
+- Trend: ${observation.confidenceTrend}
+- History: [${observation.confidenceHistory.map((c) => (c * 100).toFixed(0) + '%').join(', ')}]
+
+## Resource Usage
+- Tokens used: ${observation.tokensUsed}
+- Time elapsed: ${observation.timeElapsed}ms
+- Budget remaining: ${((observation.budgetRemaining ?? 0) * 100).toFixed(1)}%
+
+## Quality Metrics
+- Tool success rate: ${(observation.toolSuccessRate * 100).toFixed(1)}%
+- Repetition score: ${(observation.repetitionScore * 100).toFixed(1)}% (lower is better)
+
+## Recent Actions
+${(observation.recentActions ?? []).map((a) => `- ${a.type}: ${a.toolName ?? 'N/A'} ${a.error ? '(ERROR: ' + a.error + ')' : ''}`).join('\n') || 'None'}
+
+## Recent Insights
+${(observation.recentInsights ?? [] as Array<{ type?: string; content?: string }>).map((i) => {
+  const insight = i as { type?: string; content?: string };
+  return `- [${insight.type ?? 'insight'}] ${insight.content ?? ''}`;
+}).join('\n') || 'None'}
+
+## Available Modes for Switching
+${context.allowedModes.map((m) => `- ${m}`).join('\n')}
+
+---
+
+Analyze the agent's reasoning process and respond with a JSON object:
+
+{
+  "onTrack": boolean,
+  "confidence": number,
+  "reasoning": "string",
+  "issues": [
+    {
+      "type": "stagnation" | "repetition" | "resource_exhaustion" | "confidence_decline" | "strategy_mismatch" | "goal_drift",
+      "severity": "low" | "medium" | "high" | "critical",
+      "description": "string"
+    }
+  ],
+  "opportunities": [
+    {
+      "type": "strategy_switch" | "temperature_adjust" | "tool_pivot" | "goal_refinement" | "context_injection",
+      "description": "string",
+      "expectedImprovement": number
+    }
+  ],
+  "recommendation": {
+    "action": "continue" | "switch_mode" | "adjust_parameters" | "inject_context" | "escalate" | "abort",
+    "newMode": "string",
+    "parameterChanges": {},
+    "contextAddition": "string",
+    "confidence": number,
+    "reasoning": "string"
+  }
+}`;
+}
+
+export interface ParsedAssessment {
+  onTrack: boolean;
+  confidence: number;
+  reasoning: string;
+  issues: Array<{
+    type: string;
+    severity: string;
+    description: string;
+  }>;
+  opportunities: Array<{
+    type: string;
+    description: string;
+    expectedImprovement: number;
+  }>;
+  recommendation: {
+    action: string;
+    newMode?: string;
+    parameterChanges?: Record<string, unknown>;
+    contextAddition?: string;
+    confidence: number;
+    reasoning: string;
+  };
+}
+
+export function parseMetaAssessmentResponse(content: string): ParsedAssessment | null {
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    return JSON.parse(jsonMatch[0]) as ParsedAssessment;
+  } catch {
+    return null;
+  }
+}
+
+export const META_REASONING_SYSTEM_PROMPT = `You are a meta-reasoning system analyzing an AI agent's reasoning process.
+Your job is to assess whether the agent is on track and recommend strategic adjustments.
+
+Key responsibilities:
+1. Detect when the agent is stuck, repeating itself, or making poor progress
+2. Identify opportunities to improve the reasoning approach
+3. Recommend mode switches or parameter adjustments when beneficial
+4. Avoid over-intervention - only recommend changes when truly needed
+
+Always respond with valid JSON matching the specified schema.`;

package/src/meta-reasoning/strategy-selector.ts

@@ -0,0 +1,179 @@
+import type {
+  ReasoningMode,
+  ReasoningModeConfig,
+  TaskProfile,
+  MetaObservation,
+} from '@cogitator-ai/types';
+import { DEFAULT_MODE_PROFILES } from '@cogitator-ai/types';
+
+export { DEFAULT_MODE_PROFILES };
+
+export interface StrategySelectorOptions {
+  allowedModes: ReasoningMode[];
+  modeProfiles: Record<ReasoningMode, ReasoningModeConfig>;
+}
+
+export interface ModeScore {
+  mode: ReasoningMode;
+  score: number;
+  reasoning: string;
+}
+
+export class StrategySelector {
+  private allowedModes: ReasoningMode[];
+  private modeProfiles: Record<ReasoningMode, ReasoningModeConfig>;
+  private modeHistory = new Map<string, Array<{ mode: ReasoningMode; success: boolean }>>();
+
+  constructor(options: StrategySelectorOptions) {
+    this.allowedModes = options.allowedModes;
+    this.modeProfiles = options.modeProfiles;
+  }
+
+  selectForTask(taskProfile: TaskProfile): ReasoningMode {
+    const scores = this.scoreModesForTask(taskProfile);
+    scores.sort((a, b) => b.score - a.score);
+    return scores[0]?.mode ?? 'analytical';
+  }
+
+  scoreModesForTask(taskProfile: TaskProfile): ModeScore[] {
+    const scores: ModeScore[] = [];
+
+    for (const mode of this.allowedModes) {
+      const score = this.calculateModeScore(mode, taskProfile);
+      scores.push(score);
+    }
+
+    return scores;
+  }
+
+  private calculateModeScore(mode: ReasoningMode, profile: TaskProfile): ModeScore {
+    let score = 0.5;
+    const reasons: string[] = [];
+
+    switch (mode) {
+      case 'analytical':
+        if (profile.requiresReasoning) {
+          score += 0.2;
+          reasons.push('Good for reasoning tasks');
+        }
+        if (profile.complexity === 'complex' || profile.complexity === 'expert') {
+          score += 0.1;
+          reasons.push('Handles complexity well');
+        }
+        break;
+
+      case 'creative':
+        if (profile.requiresCreativity) {
+          score += 0.3;
+          reasons.push('Best for creative tasks');
+        }
+        if (profile.complexity === 'simple') {
+          score += 0.1;
+          reasons.push('Works well for simpler tasks');
+        }
+        break;
+
+      case 'systematic':
+        if (profile.complexity === 'expert' || profile.complexity === 'extreme') {
+          score += 0.2;
+          reasons.push('Thorough for complex tasks');
+        }
+        if (!profile.timeConstraint || profile.timeConstraint === 'none' || profile.timeConstraint === 'relaxed') {
+          score += 0.1;
+          reasons.push('Has time for systematic approach');
+        }
+        break;
+
+      case 'intuitive':
+        if (profile.timeConstraint === 'strict') {
+          score += 0.3;
+          reasons.push('Fast for time-constrained tasks');
+        }
+        if (profile.complexity === 'simple') {
+          score += 0.2;
+          reasons.push('Efficient for simple tasks');
+        }
+        break;
+
+      case 'reflective':
+        if (profile.requiresReasoning && profile.complexity !== 'simple') {
+          score += 0.15;
+          reasons.push('Deep reflection for reasoning');
+        }
+        break;
+
+      case 'exploratory':
+        if (profile.requiresCreativity && profile.requiresReasoning) {
+          score += 0.2;
+          reasons.push('Explores multiple paths');
+        }
+        if (!profile.requiresTools) {
+          score += 0.1;
+          reasons.push('Good for open-ended problems');
+        }
+        break;
+    }
+
+    return {
+      mode,
+      score: Math.min(1, Math.max(0, score)),
+      reasoning: reasons.join('; ') || 'Default scoring',
+    };
+  }
+
+  suggestSwitch(observation: MetaObservation): ReasoningMode | null {
+    const { currentMode, stagnationCount, confidenceTrend, repetitionScore } = observation;
+
+    if (stagnationCount >= 3 || confidenceTrend === 'falling' || repetitionScore > 0.5) {
+      const alternatives = this.allowedModes.filter((m) => m !== currentMode);
+
+      if (currentMode === 'analytical' && alternatives.includes('creative')) {
+        return 'creative';
+      }
+      if (currentMode === 'creative' && alternatives.includes('systematic')) {
+        return 'systematic';
+      }
+      if (currentMode === 'systematic' && alternatives.includes('exploratory')) {
+        return 'exploratory';
+      }
+      if (currentMode === 'intuitive' && alternatives.includes('analytical')) {
+        return 'analytical';
+      }
+
+      return alternatives[0] ?? null;
+    }
+
+    return null;
+  }
+
+  recordModeOutcome(runId: string, mode: ReasoningMode, success: boolean): void {
+    if (!this.modeHistory.has(runId)) {
+      this.modeHistory.set(runId, []);
+    }
+    this.modeHistory.get(runId)!.push({ mode, success });
+  }
+
+  getModeConfig(mode: ReasoningMode): ReasoningModeConfig {
+    return this.modeProfiles[mode];
+  }
+
+  getSuccessRate(mode: ReasoningMode): number {
+    let total = 0;
+    let successful = 0;
+
+    for (const history of this.modeHistory.values()) {
+      for (const entry of history) {
+        if (entry.mode === mode) {
+          total++;
+          if (entry.success) successful++;
+        }
+      }
+    }
+
+    return total > 0 ? successful / total : 0.5;
+  }
+
+  cleanupRun(runId: string): void {
+    this.modeHistory.delete(runId);
+  }
+}