// your-script.ts
import 'dotenv/config';

import Chorus from '@dataxwalker/chorus-sdk';

const chorus = new Chorus({ apiKey: process.env.ANTHROPIC_API_KEY! });

// Agent A learns something from the user
const a = await chorus.step(
    'agent-A',
    "I'm building a fitness app in React Native",
);
console.log(a.text);
// a.newInsight → "User is building a fitness app in React Native"

// Agent B automatically knows what A learned — shared memory pool
const b = await chorus.step(
    'agent-B',
    'What tech stack should I use for the backend?',
);
console.log(b.text); // Response informed by A's insight
console.log(b.insightsUsed); // ["User is building a fitness app in React Native"]

// Streaming support
const stream = await chorus.stepStream('agent-A', 'How do I track workouts?');
for await (const chunk of stream) process.stdout.write(chunk);
const result = await stream.finalResult();

const chorus = new Chorus({
    apiKey: process.env.ANTHROPIC_API_KEY!,
    defaultModel: 'claude-haiku-4-5', // used by all agents unless overridden
});

const analyst = await chorus.step('analyst', 'Summarize the findings.');
const writer = await chorus.step('writer', 'Write the final report.', {
    model: 'claude-opus-4-5', // override for this step only
});

const result = await chorus.step('analyst', 'Summarize the latest findings.', {
    system: 'You are a financial analyst.',
    model: 'claude-opus-4-5',
    topK: 3,
});

console.log(result.text); // full agent response (clean, no markers)
console.log(result.insightsUsed); // only insights the AI found relevant to this query
console.log(result.newInsight); // new insight this agent extracted and saved, if any

interface StepResult {
    agentId: string;
    text: string; // clean response text (USED header and INSIGHT marker stripped)
    insightsUsed: string[]; // insights the AI determined were relevant to this specific query
    newInsight?: string; // new insight written to the pool, if any
    metadata: {
        timestamp: number;
        instanceId: string;
    };
}

const stream = await chorus.stepStream(
    'writer',
    'Write a summary of renewable energy trends.',
);

// All insights injected into the prompt — available immediately
console.log(stream.insightsUsed);

// Stream text to the client chunk by chunk (USED header & INSIGHT marker auto-stripped)
for await (const chunk of stream) {
    process.stdout.write(chunk); // or send via SSE / WebSocket
}

// After the first chunk arrives, AI-determined relevant insights are populated
console.log(stream.relevantInsights);

// Get the full result (insight already written to pool)
const result = await stream.finalResult();
console.log(result.newInsight); // what was written back, if any

class ChorusStream {
    readonly insightsUsed: string[]; // all insights injected into the prompt (available immediately)
    readonly relevantInsights: string[]; // insights AI marked as relevant (populated after first chunk)

    [Symbol.asyncIterator](): AsyncIterator<string>; // text delta chunks (clean, no markers)
    finalResult(): Promise<StepResult>; // full result; safe to call before or after iteration
}

const insights = await chorus.read('analyst', 5);
// → ['My own earlier insight...', 'Solar costs dropped 40% in 2025.', ...]

await chorus.write(
    'researcher',
    'Solar adoption is accelerating fastest in Southeast Asia.',
);

await chorus.clear();

// Get all entries — useful for real-time dashboards and visualizations
const pool = await chorus.getAllInsights(); // → InsightRecord[]

// Get entries written by a specific agent
const mine = await chorus.getInsightsByAgent('researcher'); // → InsightRecord[]

interface InsightRecord {
    agentId: string;
    insight: string;
    timestamp: number;
    readCount: number; // incremented each time the entry is surfaced via read()
}

const results = await chorus.parallel([
    { agentId: 'researcher', prompt: 'Find key facts about fusion energy.' },
    {
        agentId: 'analyst',
        prompt: 'Find key facts about fusion energy.',
        options: { system: 'You are a data analyst.' },
    },
    {
        agentId: 'skeptic',
        prompt: 'Find key facts about fusion energy.',
        options: { model: 'claude-opus-4-5' },
    },
]);

for (const result of results) {
    console.log(result.agentId, result.text);
}

interface ParallelTask {
    agentId: string;
    prompt: string;
    options?: StepOptions;
}

import Chorus, {
    IStorageAdapter,
    InsightRecord,
} from '@dataxwalker/chorus-sdk';

class RedisAdapter implements IStorageAdapter {
    async get(): Promise<InsightRecord[]> {
        /* read from Redis */
    }
    async add(record: InsightRecord): Promise<void> {
        /* write to Redis */
    }
    async reset(): Promise<void> {
        /* flush */
    }
}

const chorus = new Chorus({
    apiKey: process.env.ANTHROPIC_API_KEY!,
    storageAdapter: new RedisAdapter(),
});

interface IStorageAdapter {
    get(): Promise<InsightRecord[]>;
    add(record: InsightRecord): Promise<void>;
    reset(): Promise<void>;
}

const sessions = new Map<string, Chorus>();

function getSession(userId: string): Chorus {
    if (!sessions.has(userId)) {
        sessions.set(
            userId,
            new Chorus({
                apiKey: process.env.ANTHROPIC_API_KEY!,
                instanceId: userId,
            }),
        );
    }
    return sessions.get(userId)!;
}