import { LLMist, Gadget, z } from 'llmist';

// Define a tool (called "gadget" in llmist)
class Calculator extends Gadget({
  description: 'Performs arithmetic operations',
  schema: z.object({
    operation: z.enum(['add', 'multiply', 'subtract', 'divide']),
    a: z.number(),
    b: z.number(),
  }),
}) {
  execute(params: this['params']): string {
    const { operation, a, b } = params; // Automatically typed!
    switch (operation) {
      case 'add': return `${a + b}`;
      case 'multiply': return `${a * b}`;
      case 'subtract': return `${a - b}`;
      case 'divide': return `${a / b}`;
      default: throw new Error('Unknown operation');
    }
  }
}

// Create and run agent with fluent API
const answer = await LLMist.createAgent()
  .withModel('gpt-5-nano')  // Model shortcuts: sonnet, haiku, etc.
  .withSystem('You are a helpful math assistant')
  .withGadgets(Calculator)
  .askAndCollect('What is 15 times 23?');

console.log(answer); // "15 times 23 equals 345"

// Use model shortcuts
.withModel('gpt-5-nano')    // OpenAI gpt-5-nano
.withModel('sonnet')       // Claude Sonnet 4.5
.withModel('haiku')        // Claude Haiku 4.5
.withModel('flash')        // Gemini 2.0 Flash

// Or full names
.withModel('openai:gpt-5-nano')
.withModel('anthropic:claude-sonnet-4-5')
.withModel('gemini:gemini-2.0-flash')

// 1. Class-based with type safety
class Weather extends Gadget({
  description: 'Get weather for a city',
  schema: z.object({ city: z.string() }),
}) {
  async execute(params: this['params']) {
    // params is auto-typed!
    const data = await fetch(`https://api.weather.com/${params.city}`);
    return `Weather: ${data.temp}°C`;
  }
}

// 2. Functional for simplicity
const calculator = createGadget({
  description: 'Arithmetic operations',
  schema: z.object({ operation: z.enum(['add']), a: z.number(), b: z.number() }),
  execute: ({ operation, a, b }) => `${a + b}`,
});

import { LLMist, HookPresets } from 'llmist';

// Full monitoring suite (recommended for development)
await LLMist.createAgent()
  .withHooks(HookPresets.monitoring())
  .ask('Your prompt');
// Output: Logs + timing + token tracking + error logging

// Combine specific presets for focused monitoring
await LLMist.createAgent()
  .withHooks(HookPresets.merge(
    HookPresets.timing(),
    HookPresets.tokenTracking()
  ))
  .ask('Your prompt');

// Environment-based configuration
const isDev = process.env.NODE_ENV === 'development';
const hooks = isDev
  ? HookPresets.monitoring({ verbose: true })  // Full visibility in dev
  : HookPresets.merge(
      HookPresets.errorLogging(),              // Only errors in prod
      HookPresets.tokenTracking()              // Track costs
    );

await LLMist.createAgent()
  .withHooks(hooks)
  .ask('Your prompt');

// Observers: read-only monitoring
.withHooks({
  observers: {
    onLLMCallComplete: async (ctx) => {
      console.log(`Used ${ctx.usage?.totalTokens} tokens`);
      await sendMetricsToDataDog(ctx);
    },
  },
})

// Interceptors: transform data in flight
.withHooks({
  interceptors: {
    interceptTextChunk: (chunk) => chunk.toUpperCase(),
  },
})

// Controllers: control execution flow
.withHooks({
  controllers: {
    beforeLLMCall: async (ctx) => {
      if (shouldCache(ctx)) {
        return { action: 'skip', syntheticResponse: cachedResponse };
      }
      return { action: 'proceed' };
    },
  },
})

class AskUser extends Gadget({
  description: 'Ask the user a question',
  schema: z.object({ question: z.string() }),
}) {
  execute(params: this['params']) {
    throw new HumanInputException(params.question);
  }
}

await LLMist.createAgent()
  .withGadgets(AskUser)
  .onHumanInput(async (question) => {
    return await promptUser(question);
  })
  .ask('Help me plan my vacation');

// Collect all text
const answer = await LLMist.createAgent()
  .withModel('haiku')
  .askAndCollect('Tell me a joke');

// Handle specific events
await LLMist.createAgent()
  .withModel('sonnet')
  .withGadgets(Calculator)
  .askWith('Calculate 2 + 2', {
    onText: (text) => console.log('LLM:', text),
    onGadgetCall: (call) => console.log('Calling:', call.gadgetName),
    onGadgetResult: (result) => console.log('Result:', result.result),
  });

// Manual control
const agent = LLMist.createAgent().withModel('gpt-5-nano').ask('Question');
for await (const event of agent.run()) {
  if (event.type === 'text') console.log(event.content);
}

import { LLMist, mockLLM, createMockClient } from 'llmist';

mockLLM()
  .forModel('gpt-5')
  .whenMessageContains('calculate')
  .returns('The answer is 42')
  .register();

const mockClient = createMockClient();
const answer = await mockClient.createAgent()
  .withModel('gpt-5')
  .askAndCollect('Calculate 2 + 2');

console.log(answer); // "The answer is 42" - no API call made!

const client = new LLMist();

// Get model specs
const gpt5 = client.modelRegistry.getModelSpec('gpt-5');
console.log(gpt5.contextWindow);    // 272000
console.log(gpt5.pricing.input);    // 1.25 per 1M tokens

// Estimate costs
const cost = client.modelRegistry.estimateCost('gpt-5', 10_000, 2_000);
console.log(`$${cost.totalCost.toFixed(4)}`);

// Find cheapest model
const cheapest = client.modelRegistry.getCheapestModel(10_000, 2_000);

const messages = [
  { role: 'system', content: 'You are helpful' },
  { role: 'user', content: 'Explain quantum computing' }
];

const tokens = await client.countTokens('openai:gpt-5', messages);
const cost = client.modelRegistry.estimateCost('gpt-5', tokens, 1000);