import { createAgent, defaultCodingTools } from "@cuylabs/agent-code";
import { openai } from "@ai-sdk/openai";

// Create an agent with GPT-4o
const agent = createAgent({
  model: openai("gpt-4o"),
  cwd: process.cwd(),
  tools: defaultCodingTools,
});

// Non-streaming usage
const { response, toolCalls } = await agent.send(
  "session-1",
  "List all TypeScript files in the src directory"
);
console.log(response);

// Streaming usage
for await (const event of agent.chat("session-1", "Fix the bug in utils.ts")) {
  switch (event.type) {
    case "text-delta":
      process.stdout.write(event.text);
      break;
    case "tool-start":
      console.log(`\n🔧 ${event.toolName}...`);
      break;
    case "tool-result":
      console.log(`✅ ${event.toolName} complete`);
      break;
    case "error":
      console.error(`❌ Error:`, event.error);
      break;
  }
}

import { createAgent, Tool } from "@cuylabs/agent-code";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

const myTool = Tool.define("my_custom_tool", {
  description: "Does something custom",
  parameters: z.object({
    input: z.string().describe("The input to process"),
  }),
  execute: async (params, ctx) => ({
    title: "Custom Tool",
    output: `Processed: ${params.input}`,
    metadata: {},
  }),
});

const agent = createAgent({
  model: openai("gpt-4o"),
  cwd: process.cwd(),
});

agent.addTool(myTool);

// OpenAI (recommended)
import { openai } from "@ai-sdk/openai";
const agent = createAgent({ 
  model: openai("gpt-4o"),
  cwd: process.cwd(),
});

// OpenAI with reasoning
const reasoningAgent = createAgent({ 
  model: openai("o3-mini"),
  cwd: process.cwd(),
  reasoningLevel: "high",
});

// Anthropic
import { anthropic } from "@ai-sdk/anthropic";
const agent = createAgent({ 
  model: anthropic("claude-sonnet-4-20250514"),
  cwd: process.cwd(),
});

// Google
import { google } from "@ai-sdk/google";
const agent = createAgent({ 
  model: google("gemini-2.0-flash"),
  cwd: process.cwd(),
});

import { createAgent, defaultCodingTools, readTool, grepTool, globTool } from "@cuylabs/agent-code";
import { openai } from "@ai-sdk/openai";

const agent = createAgent({
  // Required: Vercel AI SDK model instance
  model: openai("gpt-4o"),
  
  // Working directory for file operations (default: process.cwd())
  cwd: "/path/to/project",
  
  // System prompt (has sensible defaults for coding)
  systemPrompt: "You are a helpful coding assistant...",
  
  // Temperature (0-1, default varies by provider)
  temperature: 0.7,
  
  // Max output tokens (default: 32000)
  maxOutputTokens: 16000,
  
  // Max steps for tool calling loops (default: 50)
  maxSteps: 25,
  
  // Reasoning level for reasoning models (default: "off")
  reasoningLevel: "high", // "off", "low", "medium", "high"
  
  // Tools to enable (defaults to empty, use defaultCodingTools for all)
  tools: defaultCodingTools,
  
  // Or use a subset for read-only operations
  // tools: [readTool, grepTool, globTool],
});

// Sessions are managed automatically
// Just use a unique session ID for each conversation

// List all sessions
const sessions = await agent.listSessions();

// Delete a session
await agent.deleteSession("session-id");

// Get current session's messages
const messages = agent.getMessages();

// Branch from current point (for undo/redo)
const branchId = await agent.branch("checkpoint before refactor");

type AgentEvent =
  // Text streaming
  | { type: "text-start" }
  | { type: "text-delta"; text: string }
  | { type: "text-end" }
  
  // Reasoning (for o3-mini, etc.)
  | { type: "reasoning-start"; id: string }
  | { type: "reasoning-delta"; id: string; text: string }
  | { type: "reasoning-end"; id: string }
  
  // Tool execution
  | { type: "tool-start"; toolName: string; toolCallId: string; input: unknown }
  | { type: "tool-result"; toolName: string; toolCallId: string; result: unknown }
  | { type: "tool-error"; toolName: string; toolCallId: string; error: string }
  
  // Progress
  | { type: "step-start"; step: number; maxSteps: number }
  | { type: "step-finish"; step: number; usage?: TokenUsage; finishReason?: string }
  
  // Completion
  | { type: "error"; error: Error }
  | { type: "complete"; usage?: TokenUsage };