Parameters

const result = await tracia.runLocal(input: RunLocalInput);

interface LocalPromptMessage {
  role: 'system' | 'user' | 'assistant' | 'tool';
  content: string | ContentPart[];
  toolCallId?: string;  // Required for 'tool' role
  toolName?: string;    // Required for 'tool' role
}

// Content parts for assistant messages with tool calls
type ContentPart = TextPart | ToolCallPart;

interface TextPart {
  type: 'text';
  text: string;
}

interface ToolCallPart {
  type: 'tool_call';
  id: string;
  name: string;
  arguments: Record<string, unknown>;
}

const stream = tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Write a story.' }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk);
}

const result = await stream.result;

const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Write a poem.' }],
  temperature: 0.9,
  maxOutputTokens: 500,
  topP: 0.95,
  stopSequences: ['---', 'THE END'],
  timeoutMs: 30000
});

interface ToolDefinition {
  name: string;
  description: string;
  parameters: JSONSchema;  // JSON Schema for the tool's parameters
}

type ToolChoice =
  | 'auto'      // Model decides whether to use tools
  | 'none'      // Model cannot use tools
  | 'required'  // Model must use a tool
  | { tool: string }  // Model must use the specified tool

// Step 1: Initial request with tools
const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
  tools: [{
    name: 'get_weather',
    description: 'Get current weather for a location',
    parameters: {
      type: 'object',
      properties: {
        location: { type: 'string', description: 'City name' }
      },
      required: ['location']
    }
  }],
  toolChoice: 'auto'
});

// Step 2: Handle tool calls
if (result.finishReason === 'tool_calls') {
  const toolCall = result.toolCalls[0];

  // Execute your tool
  const weatherData = await getWeather(toolCall.arguments.location);

  // Step 3: Continue with tool result
  const followUp = await tracia.runLocal({
    model: 'gpt-4o',
    messages: [
      { role: 'user', content: 'What is the weather in Tokyo?' },
      result.message,  // Assistant's message (includes tool calls)
      {
        role: 'tool',
        toolCallId: toolCall.id,
        toolName: toolCall.name,
        content: JSON.stringify(weatherData)
      }
    ],
    tools: [/* same tools */]
  });

  console.log(followUp.text); // "The weather in Tokyo is 22°C and sunny."
}

const result = await tracia.runLocal({
  model: 'my-fine-tuned-gpt4',
  provider: 'openai', // Required for custom models
  messages: [{ role: 'user', content: 'Hello!' }]
});

const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello!' }],
  providerApiKey: 'sk-different-key-for-this-request'
});

// OpenAI: enable strict JSON schema for tool calls
const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Return a JSON object with name and age.' }],
  customOptions: {
    openai: { strictJsonSchema: true }
  }
});

// Anthropic: custom metadata
const result = await tracia.runLocal({
  model: 'claude-sonnet-4-20250514',
  messages: [{ role: 'user', content: 'Hello!' }],
  customOptions: {
    anthropic: { metadata: { user_id: 'user-123' } }
  }
});

// Google: safety settings
const result = await tracia.runLocal({
  model: 'gemini-2.0-flash',
  messages: [{ role: 'user', content: 'Hello!' }],
  customOptions: {
    google: {
      safetySettings: [
        { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_LOW_AND_ABOVE' }
      ]
    }
  }
});

const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'You help with {{topic}}.' },
    { role: 'user', content: 'Explain {{concept}} to a {{audience}}.' }
  ],
  variables: {
    topic: 'programming',
    concept: 'recursion',
    audience: 'beginner'
  }
});

const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello!' }],
  tags: ['production', 'chat'],
  userId: 'user_123',
  sessionId: 'session_abc',
  spanId: 'sp_1234567890abcdef'
});

// First call
const result1 = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello!' }],
});

// Second call - linked to first
const result2 = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [...],
  traceId: result1.spanId,      // Group all spans in this session
  parentSpanId: result1.spanId, // Chain to parent span
});

const result = await tracia.runLocal({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello!' }],
  sendTrace: false
});

console.log(result.spanId); // Empty string

const result = await tracia.runLocal({
  // Required
  model: 'claude-sonnet-4-20250514',
  messages: [
    { role: 'system', content: 'You are a {{role}}.' },
    { role: 'user', content: '{{question}}' }
  ],

  // LLM configuration
  temperature: 0.7,
  maxOutputTokens: 1000,
  topP: 0.9,
  stopSequences: ['---'],
  timeoutMs: 60000,

  // Provider configuration
  providerApiKey: process.env.ANTHROPIC_API_KEY_PROD,

  // Variables
  variables: {
    role: 'helpful assistant',
    question: 'What is the meaning of life?'
  },

  // Tracing
  tags: ['production', 'philosophy'],
  userId: 'user_123',
  sessionId: 'session_abc'
});