Context Management

class ProjectManager {
  private sessionId: string;
  private messageCount: number = 0;
  private summaries: Array<{ count: number; summary: string }> = [];

  async initialize(projectDetails: any) {
    const init = await agentbase.runAgent({
      message: `Initialize project management for:
      ${JSON.stringify(projectDetails, null, 2)}`,
      system: "You are a project manager tracking a long-term software project."
    });

    this.sessionId = init.session;
    return this.sessionId;
  }

  async addUpdate(update: string) {
    this.messageCount++;

    // Provide recent summary as context if available
    const recentSummary = this.summaries[this.summaries.length - 1];
    const contextMessage = recentSummary
      ? `Previous summary (from message ${recentSummary.count}):
         ${recentSummary.summary}

         New update: ${update}`
      : update;

    const result = await agentbase.runAgent({
      message: contextMessage,
      session: this.sessionId
    });

    // Summarize every 25 messages
    if (this.messageCount % 25 === 0) {
      await this.createSummary();
    }

    return result;
  }

  private async createSummary() {
    const summary = await agentbase.runAgent({
      message: "Create a comprehensive project status summary",
      session: this.sessionId
    });

    this.summaries.push({
      count: this.messageCount,
      summary: summary.message
    });
  }

  async getStatus() {
    return await agentbase.runAgent({
      message: "Provide current project status, recent progress, and next steps",
      session: this.sessionId
    });
  }
}

async function customerSupportWithContext(customerId: string) {
  // Load customer context
  const customer = await getCustomerData(customerId);

  // Create context-rich session
  const session = await agentbase.runAgent({
    message: "Customer initiated support request",
    system: `You are a customer support agent.

    CUSTOMER CONTEXT:
    Name: ${customer.name}
    Account Type: ${customer.accountType}
    Member Since: ${customer.memberSince}
    Lifetime Value: $${customer.lifetimeValue}
    Support History: ${customer.supportTickets} previous tickets
    Recent Activity: ${customer.recentActivity}
    Current Issues: ${customer.openIssues.join(', ')}

    Provide personalized support based on their history and value.
    Reference their account type and previous interactions when relevant.`
  });

  return {
    sessionId: session.session,
    handleMessage: async (message: string) => {
      return await agentbase.runAgent({
        message,
        session: session.session
        // All customer context automatically maintained
      });
    }
  };
}

async function researchWithContext(topic: string) {
  // Initialize research session with scope
  const init = await agentbase.runAgent({
    message: `Starting comprehensive research on: ${topic}

    Research Goals:
    1. Understand current state of technology
    2. Identify key players and solutions
    3. Analyze market trends
    4. Assess opportunities and challenges
    5. Compile actionable insights`,
    system: "You are a research analyst. Maintain a running compilation of findings."
  });

  const sessionId = init.session;

  // Each research phase adds to context
  await agentbase.runAgent({
    message: "Phase 1: Research academic literature and papers",
    session: sessionId
  });

  await agentbase.runAgent({
    message: "Phase 2: Analyze industry reports and market data",
    session: sessionId
    // Can reference academic findings from Phase 1
  });

  await agentbase.runAgent({
    message: "Phase 3: Study competitor approaches and solutions",
    session: sessionId
    // Can reference both previous phases
  });

  // Final synthesis with full context
  const report = await agentbase.runAgent({
    message: `Create comprehensive research report synthesizing all findings from:
    - Academic research
    - Industry reports
    - Competitor analysis

    Include executive summary, detailed findings, and recommendations.`,
    session: sessionId
    // Agent has full context from all research phases
  });

  return report;
}

async function iterativeDevelopment() {
  // Start with requirements
  const requirements = await agentbase.runAgent({
    message: `Build a REST API for user management with these requirements:
    - User CRUD operations
    - Authentication with JWT
    - Role-based access control
    - PostgreSQL database
    - Express.js framework
    - Comprehensive error handling
    - API documentation`
  });

  const sessionId = requirements.session;

  // Design phase - agent remembers requirements
  await agentbase.runAgent({
    message: "Design the database schema and API endpoints",
    session: sessionId
  });

  // Implementation - agent remembers design
  await agentbase.runAgent({
    message: "Implement user authentication and JWT token generation",
    session: sessionId
  });

  // Testing - agent knows implementation details
  await agentbase.runAgent({
    message: "Create comprehensive test suite for authentication",
    session: sessionId
  });

  // Documentation - agent has full project context
  const docs = await agentbase.runAgent({
    message: "Generate API documentation covering all endpoints and examples",
    session: sessionId
    // Can document everything because it was involved in building it
  });

  return docs;
}

async function multiDocumentAnalysis(documents: string[]) {
  // Initialize analysis session
  const init = await agentbase.runAgent({
    message: `Analyzing ${documents.length} legal documents for consistency and compliance.

    Documents to analyze:
    ${documents.map((d, i) => `${i + 1}. ${d}`).join('\n')}

    Track common themes, inconsistencies, and compliance issues across all documents.`,
    system: "You are a legal analyst. Maintain running notes of cross-document findings."
  });

  const sessionId = init.session;

  // Analyze each document - building context
  for (const doc of documents) {
    await agentbase.runAgent({
      message: `Analyze document: ${doc}

      Note any issues, key terms, obligations, and how this relates to previously analyzed documents.`,
      session: sessionId
    });
  }

  // Final cross-document analysis with full context
  const analysis = await agentbase.runAgent({
    message: `Create comprehensive cross-document analysis covering:
    1. Common themes across all documents
    2. Inconsistencies or conflicts between documents
    3. Compliance issues
    4. Risk assessment
    5. Recommendations

    Reference specific documents in your analysis.`,
    session: sessionId
    // Agent has analyzed all documents and can reference them
  });

  return analysis;
}

async function debugWithContext() {
  // Initial bug report
  const session = await agentbase.runAgent({
    message: `Bug Report:
    - Application: E-commerce checkout
    - Issue: Payment processing fails intermittently
    - Error: "Transaction timeout after 30 seconds"
    - Frequency: ~15% of transactions
    - Impact: Lost sales, customer frustration

    Start debugging this issue.`,
    system: "You are a senior software engineer debugging production issues."
  });

  const sessionId = session.session;

  // Each debugging step adds to context
  await agentbase.runAgent({
    message: "Analyze error logs from the past week",
    session: sessionId
  });

  await agentbase.runAgent({
    message: "Check payment gateway response times",
    session: sessionId
    // Agent can correlate with error logs
  });

  await agentbase.runAgent({
    message: "Review recent code changes to checkout flow",
    session: sessionId
    // Agent can relate to gateway issues and error patterns
  });

  // Solution with full debugging context
  const solution = await agentbase.runAgent({
    message: `Based on all debugging findings:
    1. What is the root cause?
    2. What is the recommended fix?
    3. How to prevent this in the future?
    4. What monitoring should be added?`,
    session: sessionId
    // Agent has full context from entire debugging session
  });

  return solution;
}

// All context lives within a session
const session1 = await agentbase.runAgent({
  message: "Context A"
});
// Session 1 has context A

const session2 = await agentbase.runAgent({
  message: "Context B"
});
// Session 2 has completely separate context B

// Context doesn't leak between sessions

// State makes context actionable
const result = await agentbase.runAgent({
  message: "Create analysis.py with the findings we discussed"
  // Context: agent remembers what findings were discussed
  // State: analysis.py is created and persists
});

// System prompt = persistent context throughout session
const result = await agentbase.runAgent({
  message: "Help customer",
  system: `You are customer support for TechCorp.

  Company context: [always available]
  Products: [always available]
  Policies: [always available]`
  // This context persists for entire session
});

// Context follows conversation through agent transfers
const result = await agentbase.runAgent({
  message: "I have a billing question about my order #12345",
  agents: [
    { name: "Billing", description: "Handles billing" }
  ]
  // When transferred to Billing agent, they receive full context
  // including order #12345
});

// Monitor conversation length
class ContextMonitor {
  private messageCount = 0;

  async sendMessage(message: string, session: string) {
    this.messageCount++;

    // Warn at thresholds
    if (this.messageCount === 50) {
      console.warn('Consider summarizing conversation');
    }

    if (this.messageCount >= 75) {
      // Auto-summarize
      return await this.summarizeAndContinue(session, message);
    }

    return await agentbase.runAgent({ message, session });
  }

  private async summarizeAndContinue(session: string, newMessage: string) {
    const summary = await agentbase.runAgent({
      message: "Concise summary of our conversation",
      session
    });

    // Start fresh with summary
    const fresh = await agentbase.runAgent({
      message: `Context: ${summary.message}

      New message: ${newMessage}`
    });

    this.messageCount = 1;
    return fresh;
  }
}