import { createAgent, runAgent, jsonSchema } from '@localmode/core';
import { webllm } from '@localmode/webllm';
import { z } from 'zod';

// Define tools with Zod schemas
const searchTool = {
  name: 'search',
  description: 'Search a knowledge base for relevant information',
  parameters: jsonSchema(z.object({
    query: z.string().describe('The search query'),
    maxResults: z.number().default(5),
  })),
  execute: async ({ query, maxResults }) => {
    // Your search implementation
    return `Found ${maxResults} results for: ${query}`;
  },
};

// One-shot execution
const result = await runAgent({
  model: webllm.languageModel('Qwen3-1.7B-q4f16_1-MLC'),
  tools: [searchTool],
  prompt: 'What are the benefits of quantum computing?',
  maxSteps: 10,
});

console.log(result.result);       // Final answer
console.log(result.steps.length); // Number of steps taken
console.log(result.finishReason); // 'finish' | 'max_steps' | etc.

import { jsonSchema } from '@localmode/core';
import { z } from 'zod';

const calculatorTool = {
  name: 'calculate',
  description: 'Evaluate a mathematical expression',
  parameters: jsonSchema(z.object({
    expression: z.string().describe('Math expression like "2 + 2"'),
  })),
  execute: async ({ expression }, { abortSignal, stepIndex }) => {
    // The context provides AbortSignal and current step index
    abortSignal.throwIfAborted();
    return String(eval(expression));
  },
};

const agent = createAgent({
  model: webllm.languageModel('Qwen3-1.7B-q4f16_1-MLC'),
  tools: [searchTool, noteTool, calculateTool],
  systemPrompt: 'You are a research assistant. Always search before answering.',
  maxSteps: 10,
  temperature: 0,
});

// Run multiple times — each run is independent
const result1 = await agent.run({ prompt: 'Research quantum computing' });
const result2 = await agent.run({ prompt: 'Research machine learning' });

const result = await runAgent({
  model,
  tools: [searchTool],
  prompt: 'Find info about X',
  maxSteps: 5,
  onStep: (step) => console.log(`Step ${step.index}: ${step.type}`),
});

const result = await runAgent({ model, tools, prompt, maxSteps: 5 });
// result.finishReason === 'max_steps' if limit reached

const result = await runAgent({ model, tools, prompt, maxDurationMs: 30000 });
// result.finishReason === 'timeout' if duration exceeded

const controller = new AbortController();

// Cancel after 10 seconds
setTimeout(() => controller.abort(), 10000);

try {
  const result = await runAgent({
    model, tools, prompt,
    abortSignal: controller.signal,
  });
} catch (error) {
  // AbortError thrown on cancellation
}

const result = await runAgent({
  model, tools, prompt,
  onStep: (step) => {
    if (step.type === 'tool_call') {
      console.log(`Called ${step.toolName} with`, step.toolArgs);
      console.log(`Result: ${step.observation}`);
    } else {
      console.log(`Final answer: ${step.result}`);
    }
    console.log(`Duration: ${step.durationMs}ms`);
  },
});

import { createAgentMemory, createAgent } from '@localmode/core';
import { transformers } from '@localmode/transformers';

const memory = await createAgentMemory({
  embeddingModel: transformers.embedding('Xenova/bge-small-en-v1.5'),
  maxEntries: 500,
});

const agent = createAgent({ model, tools, memory });

// First run — memory is empty
await agent.run({ prompt: 'What is quantum computing?' });

// Second run — memory contains relevant context from first run
await agent.run({ prompt: 'How does it relate to cryptography?' });

// Cleanup
await memory.close();

import { useAgent } from '@localmode/react';

function ResearchAgent() {
  const { steps, result, isRunning, error, run, cancel, reset } = useAgent({
    model: webllm.languageModel('Qwen3-1.7B-q4f16_1-MLC'),
    tools: [searchTool, noteTool],
    maxSteps: 10,
  });

  return (
    <div>
      <button onClick={() => run('Research quantum computing')}>
        Start Research
      </button>

      {isRunning && <button onClick={cancel}>Stop</button>}

      {/* Steps update in real-time */}
      {steps.map(step => (
        <div key={step.index}>
          Step {step.index + 1}: {step.type === 'tool_call'
            ? `Called ${step.toolName}`
            : `Finished: ${step.result}`
          }
        </div>
      ))}

      {result && (
        <div>
          <h3>Answer</h3>
          <p>{result.result}</p>
          <p>Completed in {result.totalDurationMs}ms</p>
        </div>
      )}

      {error && <p>Error: {error.message}</p>}

      <button onClick={reset}>Reset</button>
    </div>
  );
}

const unreliableTool = {
  name: 'fetch',
  description: 'Fetch data from URL',
  parameters: jsonSchema(z.object({ url: z.string() })),
  execute: async ({ url }) => {
    throw new Error('Network timeout');
    // This becomes observation: "Error: Network timeout"
    // The model can try a different URL or a different tool
  },
};

import { AgentError } from '@localmode/core';

try {
  await runAgent({ model, tools, prompt });
} catch (error) {
  if (error instanceof AgentError) {
    console.log('Steps completed:', error.steps.length);
    console.log('Hint:', error.hint);
  }
}

import { createToolRegistry } from '@localmode/core';

const registry = createToolRegistry([searchTool, noteTool]);

registry.has('search');    // true
registry.names();          // ['search', 'note']
registry.descriptions();   // [{ name, description, parameters }]

const validated = registry.validate('search', { query: 'test' });
const result = await registry.execute('search', { query: 'test' }, context);