import { loadHarmonyEncoding, Message, Conversation, Role } from 'harmony-protocol-js';

// 1. Load encoding
const encoding = loadHarmonyEncoding();

// 2. Create conversation
const conversation = Conversation.fromMessages([
  Message.system('You are a helpful assistant.'),
  Message.user('What is 2 + 2?')
]);

// 3. Get tokens ready for your OpenAI model
const tokens = encoding.renderConversationForCompletion(conversation, Role.ASSISTANT);

// 4. Send tokens to OpenAI, get response tokens back
// const responseTokens = await openai.complete(tokens);

// 5. Parse response back to structured messages
// const messages = encoding.parseMessagesFromCompletionTokens(responseTokens, Role.ASSISTANT);

import {
  loadHarmonyEncoding,
  Message,
  Conversation,
  Role,
  Channel,
  createSystemContent
} from 'harmony-protocol-js';

const encoding = loadHarmonyEncoding();

// Create a system message with multi-channel support
const systemContent = createSystemContent()
  .withIdentity('Expert Mathematics Tutor')
  .withRequiredChannels(['analysis', 'final'])
  .withReasoningEffort('high')
  .build();

// Build conversation
const conversation = Conversation.fromMessages([
  Message.system(systemContent),
  Message.user('Solve: What is the derivative of x² + 3x + 2?')
]);

// Get tokens for your OpenAI model
const tokens = encoding.renderConversationForCompletion(conversation, Role.ASSISTANT);

// After getting response from OpenAI:
// const messages = encoding.parseMessagesFromCompletionTokens(responseTokens, Role.ASSISTANT);

import { StreamableParser, loadHarmonyEncoding, Role } from 'harmony-protocol-js';

const encoding = loadHarmonyEncoding();
const parser = new StreamableParser(encoding, Role.ASSISTANT);

// Connect to your OpenAI streaming endpoint
async function handleStreamingResponse(streamResponse: ReadableStream) {
  const reader = streamResponse.getReader();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    // Process each token as it arrives
    parser.processText(new TextDecoder().decode(value));

    // Get real-time content delta for UI updates
    const delta = parser.getLastContentDelta();
    if (delta) {
      console.log('New content:', delta);
      // Update your UI immediately
      updateStreamingUI(delta);
    }
  }

  // Get final parsed messages
  const messages = parser.intoMessages();
  console.log('Complete conversation:', messages);
}

import {
  createSystemContent,
  createToolDescription,
  createToolNamespace,
  createBrowserToolNamespace,
  createPythonToolNamespace,
  Message,
  Conversation,
  Role
} from 'harmony-protocol-js';

// Create custom tools
const mathTools = [
  createToolDescription('calculate', 'Perform mathematical calculations', {
    type: 'object',
    properties: {
      expression: { type: 'string', description: 'Math expression to evaluate' },
      precision: { type: 'number', description: 'Decimal places', default: 2 }
    },
    required: ['expression']
  }),
  createToolDescription('plot_function', 'Plot mathematical functions', {
    type: 'object',
    properties: {
      function: { type: 'string', description: 'Function to plot (e.g., x^2 + 2x + 1)' },
      xRange: { type: 'array', items: { type: 'number' }, description: '[min, max] for x-axis' }
    },
    required: ['function']
  })
];

// Create tool namespaces
const mathNamespace = createToolNamespace('math', 'Mathematical computation tools', mathTools);
const browserNamespace = createBrowserToolNamespace();
const pythonNamespace = createPythonToolNamespace();

// Build comprehensive system content
const systemContent = createSystemContent()
  .withIdentity('Advanced AI Assistant with Tool Access')
  .withRequiredChannels(['analysis', 'commentary', 'final'])
  .withReasoningEffort('high')
  .withTools(mathNamespace)
  .withTools(browserNamespace)
  .withTools(pythonNamespace)
  .build();

const conversation = new Conversation([
  Message.system(systemContent),
  Message.user('Calculate the roots of 2x² + 5x - 3 = 0 and plot the function')
]);

// Model will now have access to all defined tools
const tokens = encoding.renderConversationForCompletion(conversation, Role.ASSISTANT);

import OpenAI from 'openai';
import { loadHarmonyEncoding, Message, Conversation, Role } from 'harmony-protocol-js';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const encoding = loadHarmonyEncoding();

async function completeWithHarmony(userMessage: string) {
  // 1. Create Harmony conversation
  const conversation = Conversation.fromMessages([
    Message.system('You are a helpful assistant. Use the analysis channel for reasoning.'),
    Message.user(userMessage)
  ]);

  // 2. Render to tokens
  const tokens = encoding.renderConversationForCompletion(conversation, Role.ASSISTANT);

  // 3. Send to OpenAI (note: this is conceptual - OpenAI doesn't directly accept token arrays)
  // In practice, you'd need a compatible model that accepts Harmony-formatted text
  const harmonyText = encoding.decode(tokens);

  const response = await openai.completions.create({
    model: 'text-davinci-003', // Use your Harmony-compatible model
    prompt: harmonyText,
    max_tokens: 1000,
    stream: false
  });

  // 4. Parse response back to structured messages
  const responseText = response.choices[0].text || '';
  const responseTokens = encoding.encode(responseText);
  const messages = encoding.parseMessagesFromCompletionTokens(responseTokens, Role.ASSISTANT);

  return messages;
}

// Usage
const result = await completeWithHarmony('Explain quantum computing in simple terms');
console.log('Analysis:', result.find(m => m.channel === 'analysis')?.content);
console.log('Final Answer:', result.find(m => m.channel === 'final')?.content);

import {
  HarmonyRenderer,
  StreamingRenderer,
  renderToText,
  renderToMarkdown,
  renderToHTML,
  renderFinalOnly,
  renderSummary,
  renderChannel
} from 'harmony-protocol-js';

// Quick rendering functions
const textOutput = renderToText(conversation);
const markdownOutput = renderToMarkdown(conversation);
const htmlOutput = renderToHTML(conversation);

// Advanced rendering with custom options
const renderer = new HarmonyRenderer({
  showChannels: true,
  showRoles: true,
  channelLabels: {
    analysis: '🤔 Thinking',
    commentary: '💭 Context',
    final: '💬 Answer'
  },
  maxContentLength: 200,
  includeTimestamps: true
});

const rendered = renderer.renderConversation(conversation);
console.log('Text:', rendered.text);
console.log('Markdown:', rendered.markdown);
console.log('HTML:', rendered.html);

// Channel-specific rendering
const finalOnly = renderFinalOnly(conversation);  // User-facing content only
const analysisContent = renderChannel(conversation, Channel.ANALYSIS);

// Streaming UI support
const streamingRenderer = new StreamingRenderer();
const updates = streamingRenderer.renderIncremental(newConversation);
if (updates.hasChanges) {
  updateUI(updates.newContent);  // Real-time updates
}

// Conversation analytics
const summary = renderSummary(conversation);
console.log(summary); // "Conversation contains 5 messages across 3 channels..."

// Export formats
const structured = rendered.structured;
const csvExport = structured.messages.map(m =>
  `"${m.role}","${m.channel}","${m.content}",${m.originalLength}`
).join('\n');

import {
  HarmonyError,
  ParseError,
  RenderError,
  ValidationError
} from 'harmony-protocol-js';

try {
  // Validate conversation before processing
  const validation = conversation.validate();
  if (!validation.isValid) {
    throw new ValidationError(`Invalid conversation: ${validation.errors.join(', ')}`);
  }

  const tokens = encoding.renderConversationForCompletion(conversation, Role.ASSISTANT);
  const messages = encoding.parseMessagesFromCompletionTokens(responseTokens, Role.ASSISTANT);

} catch (error) {
  if (error instanceof ParseError) {
    console.error('Parsing failed:', error.message);
  } else if (error instanceof RenderError) {
    console.error('Rendering failed:', error.message);
  } else if (error instanceof ValidationError) {
    console.error('Validation failed:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}

import { StreamableParser, loadHarmonyEncoding, Role } from 'harmony-protocol-js';

const encoding = loadHarmonyEncoding('o200k_base');
const parser = new StreamableParser(encoding, Role.ASSISTANT);

// In practice, responseTokens would come from your OpenAI model's streaming API
const responseTokens = [200006, 1234, 5678]; // These would be from OpenAI

// Process tokens as they arrive from the model
for (const token of responseTokens) {
  parser.process(token);

  // Get content delta for real-time streaming UI updates
  const delta = parser.getLastContentDelta();
  if (delta) {
    process.stdout.write(delta); // Show new content to user immediately
  }
}

// Get final structured messages after streaming is complete
const messages = parser.intoMessages();
console.log(`\nParsed ${messages.length} messages from model output`);

import { createToolDescription } from 'harmony-protocol-js';

const customTool = createToolDescription(
  'weather',
  'Gets current weather for a location',
  {
    type: 'object',
    properties: {
      location: { type: 'string' },
      units: { type: 'string', enum: ['celsius', 'fahrenheit'] }
    },
    required: ['location']
  }
);

// ❌ This might fail
import { Message } from 'harmony-protocol-js/dist/message';

// ✅ Use this instead
import { Message } from 'harmony-protocol-js';

// For large conversations, use streaming or filtering
const finalOnly = renderFinalOnly(conversation);  // Faster
const streaming = new StreamingRenderer();        // Memory efficient