gai

// Create an Anthropic client
client := a.NewClient()

// Create a generator with system instructions
generator := NewAnthropicGenerator(
	&client.Messages,
	string(a.ModelClaudeHaiku4_5),
	"You are a helpful assistant.",
)

// Create a dialog with a user message
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the capital of France?"),
			},
		},
	},
}

// Count tokens in the dialog
tokenCount, err := generator.Count(context.Background(), dialog)
if err != nil {
	fmt.Printf("Error counting tokens: %v\n", err)
	return
}

fmt.Printf("Dialog contains approximately %d tokens\n", tokenCount)

// Add a response to the dialog
dialog = append(dialog, Message{
	Role: Assistant,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("The capital of France is Paris. It's a beautiful city known for its culture, art, and cuisine."),
		},
	},
})

// Count tokens in the updated dialog
tokenCount, err = generator.Count(context.Background(), dialog)
if err != nil {
	fmt.Printf("Error counting tokens: %v\n", err)
	return
}

fmt.Printf("Dialog with response contains approximately %d tokens\n", tokenCount)

Output:

Dialog contains approximately 20 tokens
Dialog with response contains approximately 42 tokens

// Create an Anthropic client
client := a.NewClient()

// Demonstration of how to enable system prompt caching
svc := NewAnthropicServiceWrapper(&client.Messages, EnableSystemCaching)

// Instantiate an Anthropic Generator
gen := NewAnthropicGenerator(svc, string(a.ModelClaude3_5HaikuLatest), "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Generate a response
// Note that anthropic generator requires that max generation tokens generation param be set
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(1024)})
if err != nil {
	panic(err.Error())
}
// The exact response text may vary, so we'll just print a placeholder
fmt.Println("Response received")

// Customize generation parameters
opts := GenOpts{
	Temperature:         Ptr(0.7),
	MaxGenerationTokens: Ptr(1024),
}
resp, err = gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

Output:

Response received
1

apiKey := os.Getenv("ANTHROPIC_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set ANTHROPIC_API_KEY env]")
	return
}

// This example assumes that sample.jpg is present in the current directory.
imgBytes, err := os.ReadFile("sample.jpg")
if err != nil {
	fmt.Println("[Skipped: could not open sample.jpg]")
	return
}
imgBase64 := Str(base64.StdEncoding.EncodeToString(imgBytes))

client := a.NewClient()

gen := NewAnthropicGenerator(
	&client.Messages,
	string(a.ModelClaudeHaiku4_5),
	"You are a helpful assistant.",
)
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Image,
				MimeType:     "image/jpeg",
				Content:      imgBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is in this image? (Hint, it's a character from The Croods, a DreamWorks animated movie.)"),
			},
		},
	},
}
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(512)})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) != 1 {
	panic("Expected 1 candidate, got " + fmt.Sprint(len(resp.Candidates)))
}
if len(resp.Candidates[0].Blocks) != 1 {
	panic("Expected 1 block, got " + fmt.Sprint(len(resp.Candidates[0].Blocks)))
}
fmt.Println(strings.Contains(resp.Candidates[0].Blocks[0].Content.String(), "Crood"))

Output:

true

apiKey := os.Getenv("ANTHROPIC_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set ANTHROPIC_API_KEY env]")
	return
}

// This example assumes that sample.pdf is present in the current directory.
pdfBytes, err := os.ReadFile("sample.pdf")
if err != nil {
	fmt.Println("[Skipped: could not open sample.pdf]")
	return
}

client := a.NewClient()

gen := NewAnthropicGenerator(
	&client.Messages,
	string(a.ModelClaudeSonnet4_0),
	"You are a helpful assistant.",
)

// Create a dialog with PDF content
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			TextBlock("What is the title of this PDF? Just output the title and nothing else"),
			PDFBlock(pdfBytes, "paper.pdf"),
		},
	},
}

// Generate a response
ctx := context.Background()
response, err := gen.Generate(ctx, dialog, &GenOpts{MaxGenerationTokens: Ptr(1024)})
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// The response would contain the model's analysis of the PDF
if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
	fmt.Println(response.Candidates[0].Blocks[0].Content)
}

Output:

Attention Is All You Need

// Create an Anthropic client
client := a.NewClient()

// Instantiate an Anthropic Generator
gen := NewAnthropicGenerator(&client.Messages, string(a.ModelClaudeSonnet4_0), "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Use thinking
opts := GenOpts{
	Temperature:         Ptr(1.0),
	MaxGenerationTokens: Ptr(9000),
	ThinkingBudget:      "5000",
}
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

dialog = append(dialog, resp.Candidates[0], Message{
	Role: User,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("What can you do?"),
		},
	},
})
resp, err = gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

Output:

1
1

// Create an Anthropic client
client := a.NewClient()

// Demonstration of how to enable system and multi turn message prompt caching
svc := NewAnthropicServiceWrapper(&client.Messages, EnableSystemCaching, EnableMultiTurnCaching)

// Instantiate an Anthropic Generator
gen := NewAnthropicGenerator(
	svc,
	string(a.ModelClaudeSonnet4_5),
	`You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`,
)

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the price of Apple stock?"),
			},
		},
	},
}

// Customize generation parameters
opts := GenOpts{
	ToolChoice:          "get_stock_price", // Can specify a specific tool to force invoke
	MaxGenerationTokens: Ptr(8096),
}
// Generate a response
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[0].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(8096)})
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
123.45

// Create an Anthropic client
client := a.NewClient()

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

// Instantiate an Anthropic Generator
gen := NewAnthropicGenerator(
	&client.Messages,
	string(a.ModelClaudeSonnet4_0),
	`You are a helpful assistant that compares the price of two stocks and returns the ticker of whichever is greater. 
Only mention one of the stock tickers and nothing else.

Only output the price, like
<example>
User: Which one is more expensive? Apple or NVidia?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: Apple: 123.45; Nvidia: 345.65
Assistant: Nvidia
</example>

<example>
User: Which one is more expensive? Microsft or Netflix?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: MSFT: 876.45; NFLX: 345.65
Assistant: MSFT
</example>
`,
)

// Register tools
tickerTool.Description += "\nYou can call this tool in parallel"
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Which stock, Apple vs. Microsoft, is more expensive?"),
			},
		},
	},
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{
	MaxGenerationTokens: Ptr(8096),
	ThinkingBudget:      "4000",
})
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[1].Content)
fmt.Println(resp.Candidates[0].Blocks[2].Content)

dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[1].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
}, Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[2].ID,
			ModalityType: Text,
			Content:      Str("678.45"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, &GenOpts{
	MaxGenerationTokens: Ptr(8096),
	ThinkingBudget:      "4000",
})
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
{"name":"get_stock_price","parameters":{"ticker":"MSFT"}}
MSFT

// Create an Anthropic client
client := a.NewClient()

// Demonstration of how to enable system prompt caching
svc := NewAnthropicServiceWrapper(&client.Messages, EnableSystemCaching)

// Instantiate an Anthropic Generator
gen := NewAnthropicGenerator(svc, string(a.ModelClaude3_5HaikuLatest), "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Stream a response
var blocks []Block
for chunk, err := range gen.Stream(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(1024)}) {
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	blocks = append(blocks, chunk.Block)
}

if len(blocks) > 0 {
	fmt.Println("Response received")
}

Output:

Response received

// Create an Anthropic client
client := a.NewClient()

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

// Instantiate an Anthropic Generator
gen := NewAnthropicGenerator(
	&client.Messages,
	string(a.ModelClaudeSonnet4_0),
	`You are a helpful assistant that compares the price of two stocks and returns the ticker of whichever is greater. 
Only mention one of the stock tickers and nothing else.

Only output the price, like
<example>
User: Which one is more expensive? Apple or NVidia?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: Apple: 123.45; Nvidia: 345.65
Assistant: Nvidia
</example>

<example>
User: Which one is more expensive? Microsft or Netflix?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: MSFT: 876.45; NFLX: 345.65
Assistant: MSFT
</example>
`,
)

// Register tools
tickerTool.Description += "\nYou can call this tool in parallel"
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Which stock, Apple vs. Microsoft, is more expensive?"),
			},
		},
	},
}

// Stream a response
var blocks []Block
for chunk, err := range gen.Stream(context.Background(), dialog, &GenOpts{
	MaxGenerationTokens: Ptr(32000),
	ThinkingBudget:      "10000",
}) {
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	blocks = append(blocks, chunk.Block)
}

if len(blocks) > 1 {
	fmt.Println("Response received")
}

// collect the blocks
var prevToolCallId string
var toolCalls []Block
var toolcallArgs string
var toolCallInput ToolCallInput
thinking := Block{
	BlockType:    Thinking,
	ModalityType: Text,
	MimeType:     "text/plain",
	ExtraFields:  make(map[string]interface{}),
}
thinkingStr := ""
for _, block := range blocks {
	if block.BlockType == Thinking {
		if block.Content != nil {
			thinkingStr += block.Content.String()
		}
		maps.Copy(thinking.ExtraFields, block.ExtraFields)
		continue
	}
	// Skip metadata blocks
	if block.BlockType == MetadataBlockType {
		continue
	}
	if block.ID != "" && block.ID != prevToolCallId {
		if toolcallArgs != "" {
			// Parse the arguments string into a map
			if err := json.Unmarshal([]byte(toolcallArgs), &toolCallInput.Parameters); err != nil {
				panic(err.Error())
			}

			// Marshal back to JSON for consistent representation
			toolUseJSON, err := json.Marshal(toolCallInput)
			if err != nil {
				panic(err.Error())
			}
			toolCalls[len(toolCalls)-1].Content = Str(toolUseJSON)
			toolCallInput = ToolCallInput{}
			toolcallArgs = ""
		}
		prevToolCallId = block.ID
		toolCalls = append(toolCalls, Block{
			ID:           block.ID,
			BlockType:    ToolCall,
			ModalityType: Text,
			MimeType:     "text/plain",
		})
		toolCallInput.Name = block.Content.String()
	} else {
		toolcallArgs += block.Content.String()
	}
}

thinking.Content = Str(thinkingStr)

if toolcallArgs != "" {
	// Parse the arguments string into a map
	if err := json.Unmarshal([]byte(toolcallArgs), &toolCallInput.Parameters); err != nil {
		panic(err.Error())
	}

	// Marshal back to JSON for consistent representation
	toolUseJSON, err := json.Marshal(toolCallInput)
	if err != nil {
		panic(err.Error())
	}
	toolCalls[len(toolCalls)-1].Content = Str(toolUseJSON)
	toolCallInput = ToolCallInput{}
}

fmt.Println(len(toolCalls))

assistantMsg := make([]Block, 0, len(toolCalls)+1)
assistantMsg = append(assistantMsg, thinking)
assistantMsg = append(assistantMsg, toolCalls...)

dialog = append(dialog, Message{
	Role:   Assistant,
	Blocks: assistantMsg,
},
	Message{
		Role: ToolResult,
		Blocks: []Block{
			{
				ID:           toolCalls[0].ID,
				ModalityType: Text,
				Content:      Str("123.45"),
			},
		},
	}, Message{
		Role: ToolResult,
		Blocks: []Block{
			{
				ID:           toolCalls[1].ID,
				ModalityType: Text,
				Content:      Str("678.45"),
			},
		},
	})

// Stream a response
blocks = nil
for chunk, err := range gen.Stream(context.Background(), dialog, &GenOpts{
	MaxGenerationTokens: Ptr(32000),
	ThinkingBudget:      "10000",
}) {
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	blocks = append(blocks, chunk.Block)
}

if len(blocks) > 0 {
	fmt.Println("Response received")
}

Output:

Response received
2
Response received

apiKey := os.Getenv("CEREBRAS_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set CEREBRAS_API_KEY env]")
	return
}
gen := NewCerebrasGenerator(nil, "", "qwen-3-32b", "You are a helpful assistant.", apiKey)
dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("Hello!")},
	},
}
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) == 1 && len(resp.Candidates[0].Blocks) >= 1 {
	fmt.Println("Response received")
}

Output:

Response received

apiKey := os.Getenv("CEREBRAS_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set CEREBRAS_API_KEY env]")
	return
}

// Use gpt-oss-120b model which supports reasoning with reasoning_effort parameter
gen := NewCerebrasGenerator(
	nil,
	"",
	"gpt-oss-120b",
	"You are a helpful assistant that explains your reasoning step by step.",
	apiKey,
)

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the square root of 144?"),
			},
		},
	},
}

// Generate response with reasoning enabled (medium effort)
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{
	ThinkingBudget: "medium",
})
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	// Check if we have thinking blocks (reasoning)
	hasThinking := false
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Thinking {
			hasThinking = true
			fmt.Println("Reasoning found")
		}
	}

	if hasThinking {
		fmt.Println("Thinking blocks found")
	}

	// Find the main content block (not thinking)
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Content {
			content := block.Content.String()
			if strings.Contains(content, "12") {
				fmt.Println("Correct answer found")
			}
			break
		}
	}
}

// Append the previous response and ask a follow-up question to test reasoning retention
dialog = append(dialog, resp.Candidates[0], Message{
	Role: User,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("What is the square root of 225?"),
		},
	},
})

// Generate response with reasoning (the previous reasoning should be retained)
resp, err = gen.Generate(context.Background(), dialog, &GenOpts{
	ThinkingBudget: "medium",
})
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	// Check if we have thinking blocks
	hasThinking := false
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Thinking {
			hasThinking = true
		}
	}

	if hasThinking {
		fmt.Println("Thinking blocks found")
	}

	// Find the main content block
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Content {
			content := block.Content.String()
			if strings.Contains(content, "15") {
				fmt.Println("Correct answer found")
			}
			break
		}
	}
}

Output:

Reasoning found
Thinking blocks found
Correct answer found
Thinking blocks found
Correct answer found

apiKey := os.Getenv("CEREBRAS_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set CEREBRAS_API_KEY env]")
	return
}

// Use zai-glm-4.6 model which supports reasoning with disable_reasoning parameter
gen := NewCerebrasGenerator(
	nil,
	"",
	"zai-glm-4.6",
	"You are a helpful assistant that explains your reasoning step by step.",
	apiKey,
)

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is 15 * 12?"),
			},
		},
	},
}

// Generate response with reasoning enabled (disable_reasoning: false)
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	// Check if we have thinking blocks (reasoning)
	hasThinking := false
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Thinking {
			hasThinking = true
			fmt.Println("Reasoning found")
		}
	}

	if hasThinking {
		fmt.Println("Thinking blocks found")
	}

	// Find the main content block (not thinking)
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Content {
			content := block.Content.String()
			if strings.Contains(content, "180") {
				fmt.Println("Correct answer found")
			}
			break
		}
	}
}

// Append the previous response and ask a follow-up question to test reasoning retention
dialog = append(dialog, resp.Candidates[0], Message{
	Role: User,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("Now what is 20 * 15?"),
		},
	},
})

// Generate response with reasoning (the previous reasoning should be retained)
resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	// Check if we have thinking blocks
	hasThinking := false
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Thinking {
			hasThinking = true
		}
	}

	if hasThinking {
		fmt.Println("Thinking blocks found")
	}

	// Find the main content block
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Content {
			content := block.Content.String()
			if strings.Contains(content, "300") {
				fmt.Println("Correct answer found")
			}
			break
		}
	}
}

Output:

Reasoning found
Thinking blocks found
Correct answer found
Thinking blocks found
Correct answer found

apiKey := os.Getenv("CEREBRAS_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set CEREBRAS_API_KEY env]")
	return
}
cgen := NewCerebrasGenerator(nil, "", "qwen-3-235b-a22b-instruct-2507", `You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`, apiKey)

// Register a tool
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := cgen.Register(tickerTool); err != nil {
	fmt.Println("Error:", err)
	return
}

dialog := Dialog{
	{Role: User, Blocks: []Block{TextBlock("What is the price of Apple stock?")}},
}

// Force the tool call
resp, err := cgen.Generate(context.Background(), dialog, &GenOpts{ToolChoice: "get_stock_price"})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) == 0 || len(resp.Candidates[0].Blocks) == 0 {
	fmt.Println("Error: empty response")
	return
}

// Find and print the tool call JSON
var toolCall Block
for _, b := range resp.Candidates[0].Blocks {
	if b.BlockType == ToolCall {
		toolCall = b
		break
	}
}
fmt.Println(toolCall.Content)

// Append tool result and continue the conversation
dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{ID: toolCall.ID, BlockType: Content, ModalityType: Text, MimeType: "text/plain", Content: Str("123.45")},
	},
})

// Ask model to answer now without calling tools
resp, err = cgen.Generate(context.Background(), dialog, &GenOpts{ToolChoice: "none"})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	fmt.Println(resp.Candidates[0].Blocks[0].Content)
}

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
123.45

package main

import (
	"context"
	"fmt"

	"github.com/spachava753/gai"
)

func main() {
	// This example shows how to create a fallback generator that first tries a primary generator,
	// and if that fails with rate limiting or 5xx errors, falls back to a secondary generator.

	// Create mock generators for example purposes
	primaryGen := &MockGenerator{name: "Primary Generator"}
	secondaryGen := &MockGenerator{name: "Secondary Generator"}

	// Create the fallback generator
	// By default, it will fallback on rate limits and 5xx errors
	fallbackGen, err := gai.NewFallbackGenerator(
		[]gai.Generator{primaryGen, secondaryGen},
		nil, // Use default config
	)
	if err != nil {
		fmt.Println("Error creating fallback generator:", err)
		return
	}

	// Create a dialog
	dialog := gai.Dialog{
		{
			Role: gai.User,
			Blocks: []gai.Block{
				{
					BlockType:    gai.Content,
					ModalityType: gai.Text,
					Content:      gai.Str("What are the best practices for implementing fallback strategies in AI systems?"),
				},
			},
		},
	}

	// Generate a response
	// The fallback generator will try the primary generator first, and if that fails with a rate limit or 5xx error,
	// it will automatically try the secondary generator instead.
	response, err := fallbackGen.Generate(context.Background(), dialog, nil)
	if err != nil {
		fmt.Println("Generation failed:", err)
		return
	}

	// Print the response
	if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
		fmt.Println("Response:", response.Candidates[0].Blocks[0].Content)
	}
}

// MockGenerator is a simple mock implementation of the Generator interface for example purposes
type MockGenerator struct {
	name string
}

func (m *MockGenerator) Generate(ctx context.Context, dialog gai.Dialog, options *gai.GenOpts) (gai.Response, error) {
	return gai.Response{
		Candidates: []gai.Message{
			{
				Role: gai.Assistant,
				Blocks: []gai.Block{
					{
						BlockType:    gai.Content,
						ModalityType: gai.Text,
						Content:      gai.Str(fmt.Sprintf("Response from %s", m.name)),
					},
				},
			},
		},
		FinishReason: gai.EndTurn,
	}, nil
}

package main

import (
	"context"
	"fmt"

	"github.com/spachava753/gai"
)

func main() {
	// This example shows how to create a fallback generator with a custom configuration
	// that falls back on specific HTTP status codes including 400 errors.

	// Create mock generators for example purposes
	mockGen1 := &MockGenerator{name: "Primary Generator"}
	mockGen2 := &MockGenerator{name: "Fallback Generator"}

	// Create a fallback config that also fallbacks on 400 errors
	customConfig := gai.NewHTTPStatusFallbackConfig(400, 429, 500, 502, 503)

	// Create the fallback generator with the custom config
	fallbackGen, err := gai.NewFallbackGenerator(
		[]gai.Generator{mockGen1, mockGen2},
		&customConfig,
	)
	if err != nil {
		fmt.Println("Error creating fallback generator:", err)
		return
	}

	// Use the fallback generator
	dialog := gai.Dialog{
		{
			Role: gai.User,
			Blocks: []gai.Block{
				{
					BlockType:    gai.Content,
					ModalityType: gai.Text,
					Content:      gai.Str("Hello"),
				},
			},
		},
	}

	response, err := fallbackGen.Generate(context.Background(), dialog, nil)
	if err != nil {
		fmt.Println("Generation failed:", err)
		return
	}

	// Print the response
	if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
		fmt.Println("Response:", response.Candidates[0].Blocks[0].Content)
	}
}

// MockGenerator is a simple mock implementation of the Generator interface for example purposes
type MockGenerator struct {
	name string
}

func (m *MockGenerator) Generate(ctx context.Context, dialog gai.Dialog, options *gai.GenOpts) (gai.Response, error) {
	return gai.Response{
		Candidates: []gai.Message{
			{
				Role: gai.Assistant,
				Blocks: []gai.Block{
					{
						BlockType:    gai.Content,
						ModalityType: gai.Text,
						Content:      gai.Str(fmt.Sprintf("Response from %s", m.name)),
					},
				},
			},
		},
		FinishReason: gai.EndTurn,
	}, nil
}

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	fmt.Println("Dialog contains approximately 25 tokens")
	fmt.Println("Dialog with image contains approximately 400 tokens")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

// Create a generator
g, err := NewGeminiGenerator(client, "gemini-2.5-pro", "You are a helpful assistant.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}

// Create a dialog with a user message
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the capital of France?"),
			},
		},
	},
}

// Count tokens in the dialog
tokenCount, err := g.Count(context.Background(), dialog)
if err != nil {
	fmt.Printf("Error counting tokens: %v\n", err)
	return
}

fmt.Printf("Dialog contains approximately %d tokens\n", tokenCount)

// Try to load an image to add to the dialog
imgPath := "sample.jpg"
imgBytes, err := os.ReadFile(imgPath)
if err != nil {
	fmt.Printf("Image file not found, skipping image token count example\n")
	return
}

// Add an image to the dialog
dialog = Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Image,
				MimeType:     "image/jpeg",
				Content:      Str(base64.StdEncoding.EncodeToString(imgBytes)),
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Describe this image."),
			},
		},
	},
}

// Count tokens with the image included
tokenCount, err = g.Count(context.Background(), dialog)
if err != nil {
	fmt.Printf("Error counting tokens: %v\n", err)
	return
}

fmt.Printf("Dialog with image contains approximately %d tokens\n", tokenCount)

Output:

Dialog contains approximately 15 tokens
Dialog with image contains approximately 270 tokens

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "models/gemini-3-pro-preview", "You are a helpful assistant. You respond to the user with plain text format.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}
dialog := Dialog{
	{Role: User, Blocks: []Block{{BlockType: Content, ModalityType: Text, Content: Str("What is the blooms taxonomy, and how does it related to the psychology of child development?")}}},
}
response, err := g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
	fmt.Println("Got text")
}

Output:

Got text

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

audioBytes, err := os.ReadFile("sample.wav")
if err != nil {
	fmt.Println("[Skipped: could not open sample.wav]")
	return
}
// Encode as base64 for inline audio usage
audioBase64 := Str(base64.StdEncoding.EncodeToString(audioBytes))

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "gemini-2.5-pro", "You are a helpful assistant.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}

// Using inline audio data
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Audio,
				MimeType:     "audio/wav",
				Content:      audioBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the name of person in the greeting in this audio? Return a one work response of the name"),
			},
		},
	},
}

response, err := g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
	fmt.Println(strings.ToLower(response.Candidates[0].Blocks[0].Content.String()))
}

Output:

friday

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

// ---
// This example assumes that sample.jpg is present in the current directory.
// Place a JPEG image named sample.jpg in the same directory as this file (or adjust the path).
imgBytes, err := os.ReadFile("sample.jpg")
if err != nil {
	fmt.Println("[Skipped: could not open sample.jpg]")
	return
}
// Encode as base64 for API usage
imgBase64 := Str(
	// Use standard encoding, as required for image MIME input.
	// NOTE: the Blob part in Google Gemini Go SDK accepts raw bytes, but our gai.Block expects base64 encoded string.
	// The actual Gemini implementation will decode as needed, see gai.go.
	// This mirrors how other examples do it.
	base64.StdEncoding.EncodeToString(imgBytes),
)

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "gemini-2.5-pro", "You are a helpful assistant.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Image,
				MimeType:     "image/jpeg",
				Content:      imgBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is in this image? (Hint, it's a character from The Croods, a DreamWorks animated movie.)"),
			},
		},
	},
}

response, err := g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(response.Candidates) != 1 {
	panic("Expected 1 candidate, got " + fmt.Sprint(len(response.Candidates)))
}
if len(response.Candidates[0].Blocks) != 1 {
	panic("Expected 1 block, got " + fmt.Sprint(len(response.Candidates[0].Blocks)))
}
fmt.Println(strings.Contains(response.Candidates[0].Blocks[0].Content.String(), "Crood"))

Output:

true

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "models/gemini-3-pro-preview", "You are a helpful assistant.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}

// This example assumes that sample.pdf is present in the current directory.
pdfBytes, err := os.ReadFile("sample.pdf")
if err != nil {
	fmt.Println("[Skipped: could not open sample.pdf]")
	return
}

// Create a dialog with PDF content
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			TextBlock("What is the title of this PDF? Just output the title and nothing else"),
			PDFBlock(pdfBytes, "paper.pdf"),
		},
	},
}

// Generate a response
response, err := g.Generate(ctx, dialog, &GenOpts{MaxGenerationTokens: Ptr(1024)})
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// The response would contain the model's analysis of the PDF
if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
	fmt.Println(response.Candidates[0].Blocks[0].Content)
}

Output:

Attention Is All You Need

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(
	client,
	"models/gemini-3-pro-preview",
	`You are a helpful assistant. You can call tools in parallel. 
When a user asks for the server time, always call the server time tool, don't use previously returned results`,
)
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}
stockTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
getServerTimeTool := Tool{
	Name:        "get_server_time",
	Description: "Get the current server time in UTC.",
}
err = g.Register(stockTool)
if err != nil {
	fmt.Println("Error registering tool:", err)
	return
}
err = g.Register(getServerTimeTool)
if err != nil {
	fmt.Println("Error registering tool:", err)
	return
}
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("What is the stock price for AAPL, and also tell me the server time?"),
		}},
	},
}

// Expect tool call for both tools
response, err := g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
fmt.Println("tool calling response:")
for _, block := range response.Candidates[0].Blocks {
	fmt.Printf("Block type: %s | ID: %s | Content: %s\n", block.BlockType, block.ID, block.Content)
}

dialog = append(dialog, response.Candidates[0])

// Simulate tool result for tool calls
dialog = append(dialog,
	Message{
		Role: ToolResult,
		Blocks: []Block{{
			ID:           response.Candidates[0].Blocks[0].ID,
			BlockType:    Content,
			ModalityType: Text,
			MimeType:     "text/plain",
			Content:      Str("AAPL is $200.00"),
		}},
	},
	Message{
		Role: ToolResult,
		Blocks: []Block{{
			ID:           response.Candidates[0].Blocks[1].ID,
			BlockType:    Content,
			ModalityType: Text,
			MimeType:     "text/plain",
			Content:      Str(time.Time{}.String()),
		}},
	},
)

response, err = g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

toolResult := response.Candidates[0].Blocks[0].Content.String()

fmt.Println("Response has tool results:", strings.Contains(toolResult, "AAPL") &&
	strings.Contains(toolResult, "200.00") &&
	strings.Contains(toolResult, time.Time{}.String()),
)

dialog = append(dialog, response.Candidates[0], Message{
	Role: User,
	Blocks: []Block{{
		BlockType:    Content,
		ModalityType: Text,
		Content:      Str("What is the stock price for MSFT, and also tell me the server time again?"),
	}},
})

response, err = g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
fmt.Println("tool calling response:")
for _, block := range response.Candidates[0].Blocks {
	fmt.Printf("Block type: %s | ID: %s | Content: %s\n", block.BlockType, block.ID, block.Content)
}

dialog = append(dialog, response.Candidates[0])

// Simulate tool result for tool calls
dialog = append(dialog,
	Message{
		Role: ToolResult,
		Blocks: []Block{{
			ID:           response.Candidates[0].Blocks[0].ID,
			BlockType:    Content,
			ModalityType: Text,
			MimeType:     "text/plain",
			Content:      Str("MSFT is $300.00"),
		}},
	},
	Message{
		Role: ToolResult,
		Blocks: []Block{{
			ID:           response.Candidates[0].Blocks[1].ID,
			BlockType:    Content,
			ModalityType: Text,
			MimeType:     "text/plain",
			Content:      Str(time.Time{}.Add(1 * time.Minute).String()),
		}},
	},
)

response, err = g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
fmt.Println("Response has tool results:", strings.Contains(
	response.Candidates[0].Blocks[0].Content.String(),
	"MSFT",
) && strings.Contains(
	response.Candidates[0].Blocks[0].Content.String(),
	"300",
) && strings.Contains(
	response.Candidates[0].Blocks[0].Content.String(),
	"UTC",
))

Output:

tool calling response:
Block type: tool_call | ID: toolcall-1 | Content: {"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
Block type: tool_call | ID: toolcall-2 | Content: {"name":"get_server_time","parameters":{}}
Response has tool results: true
tool calling response:
Block type: tool_call | ID: toolcall-3 | Content: {"name":"get_stock_price","parameters":{"ticker":"MSFT"}}
Block type: tool_call | ID: toolcall-4 | Content: {"name":"get_server_time","parameters":{}}
Response has tool results: true

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "models/gemini-3-pro-preview", "You are a helpful assistant.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}

// Register the get_stock_price tool
stockTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
err = g.Register(stockTool)
if err != nil {
	fmt.Println("Error registering tool:", err)
	return
}

dialog := Dialog{
	{Role: User, Blocks: []Block{{BlockType: Content, ModalityType: Text, Content: Str("Give me the current prices for AAPL, MSFT, and TSLA.")}}},
}
response, err := g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
for _, cand := range response.Candidates {
	for _, block := range cand.Blocks {
		fmt.Printf("Block type: %s | ID: %s | Content: %s\n", block.BlockType, block.ID, block.Content)
	}
}

Output:

Block type: tool_call | ID: toolcall-1 | Content: {"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
Block type: tool_call | ID: toolcall-2 | Content: {"name":"get_stock_price","parameters":{"ticker":"MSFT"}}
Block type: tool_call | ID: toolcall-3 | Content: {"name":"get_stock_price","parameters":{"ticker":"TSLA"}}

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "models/gemini-3-pro-preview", "You are a helpful assistant that can view files.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}

// Register a tool to view files
viewFileTool := Tool{
	Name:        "view_file",
	Description: "View the contents of a file. Can handle text files, images, and other media types.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			FilePath string `json:"file_path" jsonschema:"required" jsonschema_description:"The path to the file to view"`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
err = g.Register(viewFileTool)
if err != nil {
	fmt.Println("Error registering tool:", err)
	return
}

// User asks to view multiple files
dialog := Dialog{
	{Role: User, Blocks: []Block{{BlockType: Content, ModalityType: Text, Content: Str("Please view sample.jpg and README.md, and tell me what character is in the image, and what is gai from the README")}}},
}

// Model makes parallel tool calls
response, err := g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

fmt.Println("Tool calls made:")
for _, block := range response.Candidates[0].Blocks {
	if block.BlockType == Thinking {
		continue
	}
	fmt.Printf("Block type: %s | ID: %s | Content: %s\n", block.BlockType, block.ID, block.Content)
}

dialog = append(dialog, response.Candidates[0])

// Find tool call blocks (skip thinking blocks)
toolCallBlocks := []Block{}
for _, block := range response.Candidates[0].Blocks {
	if block.BlockType == ToolCall {
		toolCallBlocks = append(toolCallBlocks, block)
	}
}

if len(toolCallBlocks) < 2 {
	fmt.Println("Error: Expected at least 2 tool calls")
	return
}

// Simulate tool results - first for sample.jpg (image)
imgBytes, err := os.ReadFile("sample.jpg")
if err != nil {
	fmt.Println("[Skipped: could not open sample.jpg]")
	return
}

// Simulate tool results - for README.md (text)
readmeBytes, err := os.ReadFile("README.md")
if err != nil {
	fmt.Println("[Skipped: could not open README.md]")
	return
}

// Add both tool results in parallel
dialog = append(dialog,
	Message{
		Role: ToolResult,
		Blocks: []Block{{
			ID:           toolCallBlocks[0].ID, // First tool call
			BlockType:    Content,
			ModalityType: Image,
			MimeType:     "image/jpeg",
			Content:      Str(base64.StdEncoding.EncodeToString(imgBytes)),
		}},
	},
	Message{
		Role: ToolResult,
		Blocks: []Block{{
			ID:           toolCallBlocks[1].ID, // Second tool call
			BlockType:    Content,
			ModalityType: Text,
			MimeType:     "text/markdown",
			Content:      Str(string(readmeBytes)),
		}},
	},
)

// Get final response with tool results
response, err = g.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

fmt.Println("Response received with tool results")
fmt.Println("Response contains image content:", strings.Contains(response.Candidates[0].Blocks[0].Content.String(), "Crood"))
fmt.Println("Response contains README content:", strings.Contains(response.Candidates[0].Blocks[0].Content.String(), "gai"))

Output:

Tool calls made:
Block type: tool_call | ID: toolcall-1 | Content: {"name":"view_file","parameters":{"file_path":"sample.jpg"}}
Block type: tool_call | ID: toolcall-2 | Content: {"name":"view_file","parameters":{"file_path":"README.md"}}
Response received with tool results
Response contains image content: true
Response contains README content: true

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "models/gemini-3-pro-preview", "You are a helpful assistant. You respond to the user with plain text format.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}
dialog := Dialog{
	{Role: User, Blocks: []Block{{BlockType: Content, ModalityType: Text, Content: Str("What is the capital of France?")}}},
}
for chunk, err := range g.Stream(context.Background(), dialog, nil) {
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	// Skip metadata blocks
	if chunk.Block.BlockType == MetadataBlockType {
		continue
	}
	fmt.Println(chunk.Block.Content.String())
}

Output:

The capital of France is Paris.

apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set GEMINI_API_KEY env]")
	return
}

ctx := context.Background()
client, err := genai.NewClient(
	ctx,
	&genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
	},
)

g, err := NewGeminiGenerator(client, "models/gemini-3-pro-preview", "You are a helpful assistant.")
if err != nil {
	fmt.Println("Error creating GeminiGenerator:", err)
	return
}

// Register the get_stock_price tool
stockTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
err = g.Register(stockTool)
if err != nil {
	fmt.Println("Error registering tool:", err)
	return
}

dialog := Dialog{
	{Role: User, Blocks: []Block{{BlockType: Content, ModalityType: Text, Content: Str("Give me the current prices for AAPL, MSFT, and TSLA.")}}},
}
for chunk, err := range g.Stream(context.Background(), dialog, nil) {
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	// Skip metadata blocks
	if chunk.Block.BlockType == MetadataBlockType {
		continue
	}
	fmt.Printf("Block type: %s | ID: %s | Content: %s\n", chunk.Block.BlockType, chunk.Block.ID, chunk.Block.Content)
}

Output:

Block type: tool_call | ID: toolcall-1 | Content: get_stock_price
Block type: tool_call | ID:  | Content: {"ticker":"AAPL"}
Block type: tool_call | ID: toolcall-2 | Content: get_stock_price
Block type: tool_call | ID:  | Content: {"ticker":"MSFT"}
Block type: tool_call | ID: toolcall-3 | Content: get_stock_price
Block type: tool_call | ID:  | Content: {"ticker":"TSLA"}

// Create an OpenAI client
client := openai.NewClient()

// Create a generator
generator := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4o,
	"You are a helpful assistant.",
)

// Create a dialog with a user message
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the capital of France?"),
			},
		},
	},
}

// Count tokens in the dialog
tokenCount, err := generator.Count(context.Background(), dialog)
if err != nil {
	fmt.Printf("Error counting tokens: %v\n", err)
	return
}

fmt.Printf("Dialog contains %d tokens\n", tokenCount)

// Add a response to the dialog
dialog = append(dialog, Message{
	Role: Assistant,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("The capital of France is Paris. It's known as the 'City of Light' and is famous for landmarks like the Eiffel Tower, the Louvre Museum, and Notre-Dame Cathedral."),
		},
	},
})

// Count tokens in the updated dialog
tokenCount, err = generator.Count(context.Background(), dialog)
if err != nil {
	fmt.Printf("Error counting tokens: %v\n", err)
	return
}

fmt.Printf("Dialog with response contains %d tokens\n", tokenCount)

Output:

Dialog contains 13 tokens
Dialog with response contains 48 tokens

// Create an OpenAI client
apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(
	option.WithAPIKey(apiKey),
)

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(&client.Chat.Completions, openai.ChatModelGPT4oMini, "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
// The exact response text may vary, so we'll just print a placeholder
fmt.Println("Response received")

// Customize generation parameters
opts := GenOpts{
	TopK:                Ptr[uint](10),
	N:                   Ptr[uint](2), // Set N to a value higher than 1 to generate multiple responses in a single request
	MaxGenerationTokens: Ptr(1024),
}
resp, err = gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

Output:

Response received
2

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}

audioBytes, err := os.ReadFile("sample.wav")
if err != nil {
	fmt.Println("[Skipped: could not open sample.wav]")
	return
}
// Encode as base64 for inline audio usage
audioBase64 := Str(base64.StdEncoding.EncodeToString(audioBytes))

client := openai.NewClient(
	option.WithAPIKey(apiKey),
)
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4oAudioPreview,
	"You are a helpful assistant.",
)

// Using inline audio data
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Audio,
				MimeType:     "audio/wav",
				Content:      audioBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("In this audio, a person is introducing themselves. What is the name of person in the greeting in this audio? Return a one word response of the name"),
			},
		},
	},
}

resp, err := gen.Generate(context.Background(), dialog, &GenOpts{
	MaxGenerationTokens: Ptr(128),
})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	fmt.Println(strings.ToLower(resp.Candidates[0].Blocks[0].Content.String()))
}

Output:

friday

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
imgBytes, err := os.ReadFile("sample.jpg")
if err != nil {
	fmt.Println("[Skipped: could not open sample.jpg]")
	return
}
imgBase64 := Str(base64.StdEncoding.EncodeToString(imgBytes))

client := openai.NewClient(
	option.WithAPIKey(apiKey),
)
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4o,
	"You are a helpful assistant.",
)
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Image,
				MimeType:     "image/jpeg",
				Content:      imgBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is in this image? (Hint, it's a character from The Croods, a DreamWorks animated movie.)"),
			},
		},
	},
}
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(512)})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) != 1 {
	panic("Expected 1 candidate, got " + fmt.Sprint(len(resp.Candidates)))
}
if len(resp.Candidates[0].Blocks) != 1 {
	panic("Expected 1 block, got " + fmt.Sprint(len(resp.Candidates[0].Blocks)))
}
fmt.Println(strings.Contains(resp.Candidates[0].Blocks[0].Content.String(), "Crood"))

Output:

true

// Create an OpenAI client for open router
client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1/"),
	option.WithAPIKey(os.Getenv("OPENROUTER_API_KEY")),
)

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	"google/gemini-2.5-pro-preview-03-25",
	"You are a helpful assistant",
)
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Customize generation parameters
opts := GenOpts{
	MaxGenerationTokens: Ptr(1024),
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
// The exact response text may vary, so we'll just print a placeholder
fmt.Println("Response received")
fmt.Println(len(resp.Candidates))

Output:

Response received
1

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}

pdfBytes, err := os.ReadFile("sample.pdf")
if err != nil {
	fmt.Println("[Skipped: could not open sample.wav]")
	return
}

client := openai.NewClient(
	option.WithAPIKey(apiKey),
)
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4_1,
	"You are a helpful assistant.",
)

// Create a dialog with PDF content
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			TextBlock("What is the title of this PDF? Just output the title and nothing else"),
			PDFBlock(pdfBytes, "sample.pdf"),
		},
	},
}

// Generate a response
ctx := context.Background()
response, err := gen.Generate(ctx, dialog, nil)
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// The response would contain the model's analysis of the PDF
if len(response.Candidates) > 0 && len(response.Candidates[0].Blocks) > 0 {
	fmt.Println(response.Candidates[0].Blocks[0].Content)
}

Output:

Attention Is All You Need

// Create an OpenAI client
client := openai.NewClient()

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(&client.Chat.Completions, openai.ChatModelO3Mini, "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Customize generation parameters
opts := GenOpts{
	MaxGenerationTokens: Ptr(4096),
	ThinkingBudget:      "low",
	Temperature:         Ptr(1.0),
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
// The exact response text may vary, so we'll just print a placeholder
fmt.Println("Response received")

dialog = append(dialog, resp.Candidates[0], Message{
	Role: User,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("What can you do?"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

Output:

Response received
1

// Create an OpenAI client
client := openai.NewClient(option.WithBaseURL("https://gateway.ai.cloudflare.com/v1/4eee6dd2fdc8cebc7802c5a638f460fe/cpe/openai/"))

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4oMini,
	`You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`,
)

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the price of Apple stock?"),
			},
		},
	},
}

// Customize generation parameters
opts := GenOpts{
	ToolChoice: "get_stock_price", // Can specify a specific tool to force invoke
}
// Generate a response
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[0].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
123.45

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

// Create an OpenAI client for open router
client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1/"),
	option.WithAPIKey(os.Getenv("OPENROUTER_API_KEY")),
)

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	"google/gemini-2.5-pro-preview-03-25",
	`You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`,
)

if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the price of Apple stock?"),
			},
		},
	},
}

// Customize generation parameters
opts := GenOpts{
	ToolChoice: "get_stock_price", // Can specify a specific tool to force invoke
}
// Generate a response
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[0].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
123.45

// Create an OpenAI client
client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1/"),
	option.WithAPIKey(os.Getenv("OPENROUTER_API_KEY")),
)

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	"google/gemini-2.5-pro-preview-03-25",
	`You are a helpful assistant that compares the price of two stocks and returns the ticker of whichever is greater.
Only mentioned the ticker and nothing else.

Only output the price, like
<example>
User: Which one is more expensive? Apple or NVidia?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: Apple: 123.45; Nvidia: 345.65
Assistant: Nvidia
</example>
`,
)

// Register tools
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Which stock, Apple vs. Microsoft, is more expensive?"),
			},
		},
	},
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)
fmt.Println(resp.Candidates[0].Blocks[1].Content)

dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[0].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
}, Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[1].ID,
			ModalityType: Text,
			Content:      Str("678.45"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
{"name":"get_stock_price","parameters":{"ticker":"MSFT"}}
MSFT

// Create an OpenAI client
client := openai.NewClient()

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4oMini,
	`You are a helpful assistant that compares the price of two stocks and returns the ticker of whichever is greater.
Only mentioned the ticker and nothing else.

Only output the price, like
<example>
User: Which one is more expensive? Apple or NVidia?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: Apple: 123.45; Nvidia: 345.65
Assistant: Nvidia
</example>
`,
)

// Register tools
tickerTool.Description += "\nYou can call this tool in parallel"
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Which stock, Apple vs. Microsoft, is more expensive?"),
			},
		},
	},
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)
fmt.Println(resp.Candidates[0].Blocks[1].Content)

dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[0].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
}, Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           resp.Candidates[0].Blocks[1].ID,
			ModalityType: Text,
			Content:      Str("678.45"),
		},
	},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println(resp.Candidates[0].Blocks[0].Content)

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
{"name":"get_stock_price","parameters":{"ticker":"MSFT"}}
MSFT

// Create an OpenAI client
apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(
	option.WithAPIKey(apiKey),
)

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(&client.Chat.Completions, openai.ChatModelGPT4oMini, "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Stream a response
blocks := make([][]Block, 2)
for chunk, err := range gen.Stream(context.Background(), dialog, &GenOpts{N: Ptr[uint](2)}) {
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	blocks[chunk.CandidatesIndex] = append(blocks[chunk.CandidatesIndex], chunk.Block)
}

if len(blocks) == 2 && len(blocks[0]) > 1 && len(blocks[1]) > 1 {
	fmt.Println("Response received")
}

Output:

Response received

// Create an OpenAI client
apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(
	option.WithAPIKey(apiKey),
)

// Register tools
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(&client.Chat.Completions, openai.ChatModelGPT4oMini, "You are a helpful assistant")

// Register tools
tickerTool.Description += "\nYou can call this tool in parallel"
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Which stock, Apple vs. Microsoft, is more expensive?"),
			},
		},
	},
}

// Stream a response
var blocks []Block
for chunk, err := range gen.Stream(context.Background(), dialog, nil) {
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	blocks = append(blocks, chunk.Block)
}

if len(blocks) > 1 {
	fmt.Println("Response received")
}

// collect the blocks
var prevToolCallId string
var toolCalls []Block
var toolcallArgs string
var toolCallInput ToolCallInput
for _, block := range blocks {
	// Skip metadata blocks
	if block.BlockType == MetadataBlockType {
		continue
	}
	if block.ID != "" && block.ID != prevToolCallId {
		if toolcallArgs != "" {
			// Parse the arguments string into a map
			if err := json.Unmarshal([]byte(toolcallArgs), &toolCallInput.Parameters); err != nil {
				panic(err.Error())
			}

			// Marshal back to JSON for consistent representation
			toolUseJSON, err := json.Marshal(toolCallInput)
			if err != nil {
				panic(err.Error())
			}
			toolCalls[len(toolCalls)-1].Content = Str(toolUseJSON)
			toolCallInput = ToolCallInput{}
			toolcallArgs = ""
		}
		prevToolCallId = block.ID
		toolCalls = append(toolCalls, Block{
			ID:           block.ID,
			BlockType:    ToolCall,
			ModalityType: Text,
			MimeType:     "text/plain",
		})
		toolCallInput.Name = block.Content.String()
	} else {
		toolcallArgs += block.Content.String()
	}
}

if toolcallArgs != "" {
	// Parse the arguments string into a map
	if err := json.Unmarshal([]byte(toolcallArgs), &toolCallInput.Parameters); err != nil {
		panic(err.Error())
	}

	// Marshal back to JSON for consistent representation
	toolUseJSON, err := json.Marshal(toolCallInput)
	if err != nil {
		panic(err.Error())
	}
	toolCalls[len(toolCalls)-1].Content = Str(toolUseJSON)
	toolCallInput = ToolCallInput{}
}

fmt.Println(len(toolCalls))

dialog = append(dialog, Message{
	Role:   Assistant,
	Blocks: toolCalls,
}, Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           toolCalls[0].ID,
			ModalityType: Text,
			Content:      Str("123.45"),
		},
	},
}, Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           toolCalls[1].ID,
			ModalityType: Text,
			Content:      Str("678.45"),
		},
	},
})

// Stream a response
blocks = nil
for chunk, err := range gen.Stream(context.Background(), dialog, nil) {
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	blocks = append(blocks, chunk.Block)
}

if len(blocks) > 1 {
	fmt.Println("Response received")
}

Output:

Response received
2
Response received

// Create an OpenAI client configured for OpenRouter
apiKey := os.Getenv("OPENROUTER_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENROUTER_API_KEY env]")
	return
}

client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1"),
	option.WithAPIKey(apiKey),
)

// Instantiate an OpenRouter Generator
gen := NewOpenRouterGenerator(&client.Chat.Completions, "z-ai/glm-4.6:exacto", "You are a helpful assistant")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hi!"),
			},
		},
	},
}

// Generate a response
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
// The exact response text may vary, so we'll just print a placeholder
fmt.Println("Response received")

// Customize generation parameters
opts := GenOpts{
	MaxGenerationTokens: Ptr(10000),
}
resp, err = gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

Output:

Response received
1

apiKey := os.Getenv("OPENROUTER_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENROUTER_API_KEY env]")
	return
}

imgBytes, err := os.ReadFile("sample.jpg")
if err != nil {
	fmt.Println("[Skipped: could not open sample.jpg]")
	return
}
imgBase64 := Str(base64.StdEncoding.EncodeToString(imgBytes))

client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1"),
	option.WithAPIKey(apiKey),
)

// Use a vision-capable model through OpenRouter
gen := NewOpenRouterGenerator(
	&client.Chat.Completions,
	"qwen/qwen3-vl-235b-a22b-instruct",
	"You are a helpful assistant.",
)

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Image,
				MimeType:     "image/jpeg",
				Content:      imgBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is in this image? (Hint, it's a character from The Croods, a DreamWorks animated movie.)"),
			},
		},
	},
}

resp, err := gen.Generate(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(512)})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) != 1 {
	panic("Expected 1 candidate, got " + fmt.Sprint(len(resp.Candidates)))
}
if len(resp.Candidates[0].Blocks) < 1 {
	panic("Expected at least 1 block, got " + fmt.Sprint(len(resp.Candidates[0].Blocks)))
}
fmt.Println(strings.Contains(resp.Candidates[0].Blocks[0].Content.String(), "Crood"))

Output:

true

// This example demonstrates handling of invalid model IDs with OpenRouter.
// OpenRouter returns a 400 status code with error details in the response body
// for invalid requests like nonsense model IDs.
apiKey := os.Getenv("OPENROUTER_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENROUTER_API_KEY env]")
	return
}

client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1"),
	option.WithAPIKey(apiKey),
)

// Use a nonsense model ID to trigger an error
gen := NewOpenRouterGenerator(&client.Chat.Completions, "invalid/model-does-not-exist", "You are helpful")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("Hello"),
			},
		},
	},
}

_, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	var apiErr ApiErr
	if errors.As(err, &apiErr) {
		fmt.Println("Handled error")
	} else {
		fmt.Println("Unexpected error type")
	}
	return
}
panic("unreachable")

Output:

Handled error

apiKey := os.Getenv("OPENROUTER_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENROUTER_API_KEY env]")
	return
}

client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1"),
	option.WithAPIKey(apiKey),
)

// Use a reasoning model through OpenRouter
// NOTE: Models that support reasoning (like those with extended thinking)
// will automatically return reasoning_details which are extracted as Thinking blocks
gen := NewOpenRouterGenerator(
	&client.Chat.Completions,
	"z-ai/glm-4.6:exacto",
	"You are a helpful assistant.",
)

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the square root of 144?"),
			},
		},
	},
}

// Generate response - reasoning models may return thinking blocks automatically
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{ThinkingBudget: "low"})
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	// Check if we have thinking blocks (from reasoning_details)
	hasThinking := false
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Thinking {
			hasThinking = true
			// Thinking blocks have reasoning metadata in ExtraFields
			if reasoningType, ok := block.ExtraFields["reasoning_type"].(string); ok {
				_ = reasoningType // reasoning.text, reasoning.summary, or reasoning.encrypted
			}
		}
	}

	if hasThinking {
		fmt.Println("Thinking blocks found")
	}

	// Find the main content block (not thinking)
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Content {
			content := block.Content.String()
			if strings.Contains(content, "12") {
				fmt.Println("Correct answer found")
			}
			break
		}
	}
}

dialog = append(dialog, resp.Candidates[0], Message{
	Role: User,
	Blocks: []Block{
		{
			BlockType:    Content,
			ModalityType: Text,
			Content:      Str("What is the square root of 225?"),
		},
	},
})

// Generate response - reasoning models may return thinking blocks automatically
resp, err = gen.Generate(context.Background(), dialog, &GenOpts{ThinkingBudget: "low"})
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	// Check if we have thinking blocks (from reasoning_details)
	hasThinking := false
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Thinking {
			hasThinking = true
			// Thinking blocks have reasoning metadata in ExtraFields
			if reasoningType, ok := block.ExtraFields["reasoning_type"].(string); ok {
				_ = reasoningType // reasoning.text, reasoning.summary, or reasoning.encrypted
			}
		}
	}

	if hasThinking {
		fmt.Println("Thinking blocks found")
	}

	// Find the main content block (not thinking)
	for _, block := range resp.Candidates[0].Blocks {
		if block.BlockType == Content {
			content := block.Content.String()
			if strings.Contains(content, "15") {
				fmt.Println("Correct answer found")
			}
			break
		}
	}
}

Output:

Thinking blocks found
Correct answer found
Thinking blocks found
Correct answer found

apiKey := os.Getenv("OPENROUTER_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENROUTER_API_KEY env]")
	return
}

client := openai.NewClient(
	option.WithBaseURL("https://openrouter.ai/api/v1"),
	option.WithAPIKey(apiKey),
)

gen := NewOpenRouterGenerator(
	&client.Chat.Completions,
	"moonshotai/kimi-k2-0905:exacto",
	"You are a helpful assistant that returns the price of a stock and nothing else.",
)

// Register a tool
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(tickerTool); err != nil {
	fmt.Println("Error:", err)
	return
}

dialog := Dialog{
	{Role: User, Blocks: []Block{TextBlock("What is the price of Apple stock?")}},
}

// Force the tool call
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{ToolChoice: "get_stock_price"})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) == 0 || len(resp.Candidates[0].Blocks) == 0 {
	fmt.Println("Error: empty response")
	return
}

// Find and print the tool call JSON
var toolCall Block
for _, b := range resp.Candidates[0].Blocks {
	if b.BlockType == ToolCall {
		toolCall = b
		break
	}
}
fmt.Println(toolCall.Content)

// Append tool result and continue the conversation
dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{ID: toolCall.ID, BlockType: Content, ModalityType: Text, MimeType: "text/plain", Content: Str("123.45")},
	},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) > 0 && len(resp.Candidates[0].Blocks) > 0 {
	fmt.Println(resp.Candidates[0].Blocks[0].Content)
}

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
123.45

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5Mini, "You are a helpful assistant")
dialog := Dialog{{Role: User, Blocks: []Block{TextBlock("Hi!")}}}
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
fmt.Println("Response received")
fmt.Println(len(resp.Candidates))

Output:

Response received
1

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
imgBytes, err := os.ReadFile("sample.jpg")
if err != nil {
	fmt.Println("[Skipped: could not open sample.jpg]")
	return
}
imgBase64 := Str(base64.StdEncoding.EncodeToString(imgBytes))

client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5Mini, "You are a helpful assistant.")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Image,
				MimeType:     "image/jpeg",
				Content:      imgBase64,
			},
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is in this image? (Hint, it's a character from The Croods, a DreamWorks animated movie.) Answer with only the name of the character"),
			},
		},
	},
}
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{MaxGenerationTokens: Ptr(512), ThinkingBudget: "high"})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) != 1 {
	panic("Expected 1 candidate, got " + fmt.Sprint(len(resp.Candidates)))
}
if len(resp.Candidates[0].Blocks) == 0 {
	panic("Expected at least 1 block")
}
// Find the first Content block (skip Thinking blocks from reasoning)
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == Content {
		fmt.Println(strings.Contains(blk.Content.String(), "Guy"))
		break
	}
}

Output:

true

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}

pdfBytes, err := os.ReadFile("sample.pdf")
if err != nil {
	fmt.Println("[Skipped: could not open sample.pdf]")
	return
}

client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5Mini, "You are a helpful assistant.")
dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			TextBlock("What is the title of this PDF? Just output the title and nothing else"),
			PDFBlock(pdfBytes, "sample.pdf"),
		},
	},
}
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{ThinkingBudget: "low"})
if err != nil {
	fmt.Println("Error:", err)
	return
}
// Find the first Content block (skip Thinking blocks from reasoning)
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == Content {
		fmt.Println(blk.Content)
		break
	}
}

Output:

Attention Is All You Need

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5, "You are a helpful assistant")
dialog := Dialog{{Role: User, Blocks: []Block{TextBlock("Are LLMs conscious? Think it through and give a comprehensive answer")}}}
opts := GenOpts{ThinkingBudget: "medium", Temperature: Ptr(1.0), ExtraArgs: map[string]any{
	ResponsesThoughtSummaryDetailParam: responses.ReasoningSummaryDetailed,
}}
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println("Response received")
// The generator is stateless: just append the assistant response and continue.
// Reasoning blocks with encrypted content are automatically reconstructed as
// input reasoning items on the next call.
dialog = append(dialog, resp.Candidates[0], Message{Role: User, Blocks: []Block{TextBlock("What can you do?")}})
resp, err = gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
fmt.Println(len(resp.Candidates))

Output:

Response received
1

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5Mini, `You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`)
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}
dialog := Dialog{{Role: User, Blocks: []Block{TextBlock("What is the price of Apple stock?")}}}
opts := GenOpts{ToolChoice: "get_stock_price"}
resp, err := gen.Generate(context.Background(), dialog, &opts)
if err != nil {
	panic(err.Error())
}
// Find the first ToolCall block (reasoning models may produce Thinking blocks before tool calls)
var toolCallBlock Block
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == ToolCall {
		toolCallBlock = blk
		break
	}
}
fmt.Println(toolCallBlock.Content)
// Append the assistant's response and the tool result. The generator is stateless
// and manages conversation context through the dialog.
dialog = append(dialog, resp.Candidates[0], Message{Role: ToolResult, Blocks: []Block{{ID: toolCallBlock.ID, ModalityType: Text, MimeType: "text/plain", Content: Str("123.45")}}})
resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
// Find the first Content block in the final response
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == Content {
		fmt.Println(blk.Content)
		break
	}
}

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
123.45

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5Mini, `You are a helpful assistant that compares the price of two stocks and returns the ticker of whichever is greater.
Only mentioned the ticker and nothing else.

Only output the price, like
<example>
User: Which one is more expensive? Apple or NVidia?
Assistant: calls get_stock_price for both Apple and Nvidia
Tool Result: Apple: 123.45; Nvidia: 345.65
Assistant: Nvidia
</example>
`)
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.\nYou can call this tool in parallel",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(tickerTool); err != nil {
	panic(err.Error())
}
dialog := Dialog{{Role: User, Blocks: []Block{TextBlock("Which stock, Apple vs. Microsoft, is more expensive?")}}}
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{ThinkingBudget: "medium"})
if err != nil {
	panic(err.Error())
}
// Collect ToolCall blocks (reasoning models may produce Thinking blocks before tool calls)
var toolCallBlocks []Block
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == ToolCall {
		toolCallBlocks = append(toolCallBlocks, blk)
	}
}
fmt.Println(toolCallBlocks[0].Content)
fmt.Println(toolCallBlocks[1].Content)
// Append the assistant's response and tool results. The generator is stateless
// and manages conversation context through the dialog.
dialog = append(dialog, resp.Candidates[0], Message{Role: ToolResult, Blocks: []Block{{ID: toolCallBlocks[0].ID, ModalityType: Text, MimeType: "text/plain", Content: Str("123.45")}}}, Message{Role: ToolResult, Blocks: []Block{{ID: toolCallBlocks[1].ID, ModalityType: Text, MimeType: "text/plain", Content: Str("678.45")}}})
resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	panic(err.Error())
}
// Find the first Content block in the final response
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == Content {
		fmt.Println(blk.Content)
		break
	}
}

Output:

{"name":"get_stock_price","parameters":{"ticker":"AAPL"}}
{"name":"get_stock_price","parameters":{"ticker":"MSFT"}}
MSFT

ExampleResponsesGenerator_Stream_thinking demonstrates consuming the raw streaming iterator with a reasoning model. The stream yields thinking chunks (reasoning deltas) interleaved with content chunks. At the end, a metadata block carries usage information. This example also shows how to build a dialog-ready assistant message from the streamed blocks using compressStreamingBlocks (via StreamingAdapter) for a follow-up turn.

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set OPENAI_API_KEY env]")
	return
}
client := openai.NewClient(option.WithAPIKey(apiKey))
gen := NewResponsesGenerator(&client.Responses, openai.ChatModelGPT5Nano, "You are a helpful assistant")

dialog := Dialog{{Role: User, Blocks: []Block{TextBlock("What is the capital of France? Reply with just the city name.")}}}
opts := &GenOpts{
	ThinkingBudget: "low",
	ExtraArgs: map[string]any{
		ResponsesThoughtSummaryDetailParam: responses.ReasoningSummaryDetailed,
	},
}

// Use StreamingAdapter so the streamed output is automatically compressed
// into a proper Response with Thinking blocks carrying ExtraFields (including
// encrypted reasoning content for stateless multi-turn conversations).
adapter := &StreamingAdapter{S: &gen}

resp, err := adapter.Generate(context.Background(), dialog, opts)
if err != nil {
	panic(err.Error())
}

// The compressed response preserves Thinking blocks from the reasoning model.
hasThinking := false
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == Thinking {
		hasThinking = true
		break
	}
}
fmt.Println("Has thinking blocks:", hasThinking)

// Append the full assistant message to the dialog. Thinking blocks with
// encrypted content are included, so the next call can reconstruct reasoning
// input items automatically.
dialog = append(dialog, resp.Candidates[0], Message{Role: User, Blocks: []Block{TextBlock("And what country is that in?")}})

resp, err = adapter.Generate(context.Background(), dialog, opts)
if err != nil {
	panic(err.Error())
}

// Find the content block in the follow-up response.
for _, blk := range resp.Candidates[0].Blocks {
	if blk.BlockType == Content {
		fmt.Println(strings.Contains(blk.Content.String(), "France"))
		break
	}
}

Output:

Has thinking blocks: true
true

tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

client := openai.NewClient()

// Instantiate a OpenAI Generator
gen := NewOpenAiGenerator(
	&client.Chat.Completions,
	openai.ChatModelGPT4oMini,
	`You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`,
)

tg := ToolGenerator{
	G: &gen,
}

// Register tools
if err := tg.Register(
	tickerTool,
	&TickerTool{
		ticketPrices: map[string]float64{
			"AAPL": 435.56,
		},
	},
); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the price of Apple stock?"),
			},
		},
	},
}

// Generate a response
newDialog, err := tg.Generate(context.Background(), dialog, func(d Dialog) *GenOpts {
	return nil
})
if err != nil {
	panic(err.Error())
}
fmt.Printf("len of the new dialog: %d\n", len(newDialog))
fmt.Printf("%s\n", newDialog[len(newDialog)-1].Blocks[0].Content)

Output:

len of the new dialog: 4
435.56

tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}

client := openai.NewClient()

// Instantiate a Responses Generator (stateless, no adapter needed)
gen := NewResponsesGenerator(
	&client.Responses,
	openai.ChatModelGPT5Mini,
	`You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like
<example>
435.56
</example>
<example>
3235.55
</example>
`,
)

tg := ToolGenerator{
	G: &gen,
}

// Register tools
if err := tg.Register(
	tickerTool,
	&TickerTool{
		ticketPrices: map[string]float64{
			"AAPL": 435.56,
		},
	},
); err != nil {
	panic(err.Error())
}

dialog := Dialog{
	{
		Role: User,
		Blocks: []Block{
			{
				BlockType:    Content,
				ModalityType: Text,
				Content:      Str("What is the price of Apple stock?"),
			},
		},
	},
}

// Generate a response
newDialog, err := tg.Generate(context.Background(), dialog, func(d Dialog) *GenOpts {
	return nil
})
if err != nil {
	panic(err.Error())
}
fmt.Printf("len of the new dialog: %d\n", len(newDialog))
// Find the first Content block (reasoning models may produce Thinking blocks first)
lastMsg := newDialog[len(newDialog)-1]
for _, blk := range lastMsg.Blocks {
	if blk.BlockType == Content {
		fmt.Printf("%s\n", blk.Content)
		break
	}
}

Output:

len of the new dialog: 4
435.56

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}
gen := NewZaiGenerator(nil, "glm-4.7", "You are a helpful assistant.", apiKey)
dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("Hello!")},
	},
}
resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) == 0 {
	fmt.Println("Error: no candidates returned")
	return
}
if len(resp.Candidates[0].Blocks) == 0 {
	fmt.Println("Error: no blocks in response")
	return
}
fmt.Println("Response received")

Output:

Response received

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}

// Create generator with preserved thinking (clearThinking=false)
gen := NewZaiGenerator(
	nil, "glm-4.7",
	"You are a helpful assistant.",
	apiKey,
	WithZaiClearThinking(false), // Enable preserved thinking
)

// Register a weather tool
weatherTool := Tool{
	Name:        "get_weather",
	Description: "Get the current weather for a city",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			City string `json:"city" jsonschema:"required" jsonschema_description:"The city name"`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(weatherTool); err != nil {
	fmt.Println("Error registering tool:", err)
	return
}

// First turn: ask about weather
dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("What's the weather like in Beijing?")},
	},
}

resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

// Print block types from first turn
fmt.Print("First turn:")
var toolCallBlock Block
for _, block := range resp.Candidates[0].Blocks {
	fmt.Printf(" %s", block.BlockType)
	if block.BlockType == ToolCall {
		toolCallBlock = block
	}
}
fmt.Println()

if toolCallBlock.BlockType != ToolCall {
	fmt.Println("Error: no tool call found")
	return
}

// Append assistant response and provide tool result
dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{
			ID:           toolCallBlock.ID,
			BlockType:    Content,
			ModalityType: Text,
			MimeType:     "text/plain",
			Content:      Str(`{"weather": "Sunny", "temperature": "25°C", "humidity": "40%"}`),
		},
	},
})

// Second turn: model reasons about the tool result
resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

// Print block types from second turn
fmt.Print("Second turn:")
for _, block := range resp.Candidates[0].Blocks {
	fmt.Printf(" %s", block.BlockType)
}
fmt.Println()

Output:

First turn: thinking content tool_call
Second turn: thinking content

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}

gen := NewZaiGenerator(nil, "glm-4.7", "You are a helpful math tutor.", apiKey)

// First turn
dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("What is 5 + 3?")},
	},
}

resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

found := false
for _, block := range resp.Candidates[0].Blocks {
	if block.BlockType == Content && strings.Contains(block.Content.String(), "8") {
		found = true
		break
	}
}
if !found {
	fmt.Println("Error: Turn 1 expected '8' in response")
	return
}
fmt.Println("Turn 1: correct")

// Second turn: continue conversation
dialog = append(dialog, resp.Candidates[0], Message{
	Role:   User,
	Blocks: []Block{TextBlock("Now multiply that result by 2")},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

found = false
for _, block := range resp.Candidates[0].Blocks {
	if block.BlockType == Content && strings.Contains(block.Content.String(), "16") {
		found = true
		break
	}
}
if !found {
	fmt.Println("Error: Turn 2 expected '16' in response")
	return
}
fmt.Println("Turn 2: correct")

// Third turn
dialog = append(dialog, resp.Candidates[0], Message{
	Role:   User,
	Blocks: []Block{TextBlock("Divide that by 4")},
})

resp, err = gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

found = false
for _, block := range resp.Candidates[0].Blocks {
	if block.BlockType == Content && strings.Contains(block.Content.String(), "4") {
		found = true
		break
	}
}
if !found {
	fmt.Println("Error: Turn 3 expected '4' in response")
	return
}
fmt.Println("Turn 3: correct")

Output:

Turn 1: correct
Turn 2: correct
Turn 3: correct

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}

gen := NewZaiGenerator(
	nil, "glm-4.7",
	"You are a helpful assistant that explains your reasoning step by step.",
	apiKey,
)

dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("What is the square root of 144?")},
	},
}

resp, err := gen.Generate(context.Background(), dialog, nil)
if err != nil {
	fmt.Println("Error:", err)
	return
}

if len(resp.Candidates) == 0 || len(resp.Candidates[0].Blocks) == 0 {
	fmt.Println("Error: empty response")
	return
}

// Check for thinking block
hasThinking := false
for _, block := range resp.Candidates[0].Blocks {
	if block.BlockType == Thinking {
		hasThinking = true
		break
	}
}
if !hasThinking {
	fmt.Println("Error: no thinking block found")
	return
}
fmt.Println("Thinking block found")

// Check for correct answer in content
for _, block := range resp.Candidates[0].Blocks {
	if block.BlockType == Content {
		if strings.Contains(block.Content.String(), "12") {
			fmt.Println("Correct answer found")
			return
		}
		fmt.Printf("Error: expected '12' in content, got: %s\n", block.Content.String())
		return
	}
}
fmt.Println("Error: no content block found")

Output:

Thinking block found
Correct answer found

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}

gen := NewZaiGenerator(nil, "glm-4.7", `You are a helpful assistant that returns the price of a stock and nothing else.

Only output the price, like:
<example>
435.56
</example>`, apiKey)

// Register a stock price tool
tickerTool := Tool{
	Name:        "get_stock_price",
	Description: "Get the current stock price for a given ticker symbol.",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Ticker string `json:"ticker" jsonschema:"required" jsonschema_description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(tickerTool); err != nil {
	fmt.Println("Error:", err)
	return
}

dialog := Dialog{
	{Role: User, Blocks: []Block{TextBlock("What is the price of Apple stock?")}},
}

// Force the tool call
resp, err := gen.Generate(context.Background(), dialog, &GenOpts{ToolChoice: "get_stock_price"})
if err != nil {
	fmt.Println("Error:", err)
	return
}
if len(resp.Candidates) == 0 || len(resp.Candidates[0].Blocks) == 0 {
	fmt.Println("Error: empty response")
	return
}

// Find the tool call
var toolCall Block
for _, b := range resp.Candidates[0].Blocks {
	if b.BlockType == ToolCall {
		toolCall = b
		break
	}
}

if toolCall.BlockType != ToolCall {
	fmt.Println("Error: no tool call found")
	return
}

var tc ToolCallInput
if err := json.Unmarshal([]byte(toolCall.Content.String()), &tc); err != nil {
	fmt.Println("Error parsing tool call:", err)
	return
}

if tc.Name != "get_stock_price" {
	fmt.Printf("Error: expected tool 'get_stock_price', got '%s'\n", tc.Name)
	return
}
fmt.Println("Tool call received")

// Append tool result and continue
dialog = append(dialog, resp.Candidates[0], Message{
	Role: ToolResult,
	Blocks: []Block{
		{ID: toolCall.ID, BlockType: Content, ModalityType: Text, MimeType: "text/plain", Content: Str("189.45")},
	},
})

// Get final answer without calling tools
resp, err = gen.Generate(context.Background(), dialog, &GenOpts{ToolChoice: "none"})
if err != nil {
	fmt.Println("Error:", err)
	return
}

// Check if final response contains the price from tool result
for _, block := range resp.Candidates[0].Blocks {
	if block.BlockType == Content {
		if strings.Contains(block.Content.String(), "189.45") || strings.Contains(block.Content.String(), "189") {
			fmt.Println("Final answer contains tool result")
			return
		}
		fmt.Printf("Error: expected '189.45' in answer, got: %s\n", block.Content.String())
		return
	}
}
fmt.Println("Error: no content block in final response")

Output:

Tool call received
Final answer contains tool result

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}

gen := NewZaiGenerator(nil, "glm-4.7", "You are a helpful assistant.", apiKey)
dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("Count from 1 to 5")},
	},
}

var contentChunks int
var thinkingChunks int

for chunk, err := range gen.Stream(context.Background(), dialog, nil) {
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	switch chunk.Block.BlockType {
	case Content:
		contentChunks++
	case Thinking:
		thinkingChunks++
	case MetadataBlockType:
		// ignore usage metadata
	}
}

if contentChunks == 0 {
	fmt.Println("Error: no content chunks received")
	return
}
fmt.Println("Content chunks received")

if thinkingChunks == 0 {
	fmt.Println("Error: no thinking chunks received")
	return
}
fmt.Println("Thinking chunks received")

Output:

Content chunks received
Thinking chunks received

apiKey := os.Getenv("Z_API_KEY")
if apiKey == "" {
	fmt.Println("[Skipped: set Z_API_KEY env]")
	return
}

gen := NewZaiGenerator(nil, "glm-4.7", "You are a helpful assistant.", apiKey)

// Register a calculator tool
calcTool := Tool{
	Name:        "calculate",
	Description: "Perform a mathematical calculation",
	InputSchema: func() *jsonschema.Schema {
		schema, err := GenerateSchema[struct {
			Expression string `json:"expression" jsonschema:"required" jsonschema_description:"The mathematical expression to evaluate"`
		}]()
		if err != nil {
			panic(err)
		}
		return schema
	}(),
}
if err := gen.Register(calcTool); err != nil {
	fmt.Println("Error registering tool:", err)
	return
}

dialog := Dialog{
	{
		Role:   User,
		Blocks: []Block{TextBlock("What is 123 * 456? Use the calculator tool.")},
	},
}

var hasToolCall bool

for chunk, err := range gen.Stream(context.Background(), dialog, &GenOpts{ToolChoice: ToolChoiceToolsRequired}) {
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	if chunk.Block.BlockType == ToolCall {
		hasToolCall = true
	}
}

if !hasToolCall {
	fmt.Println("Error: no tool call received in stream")
	return
}
fmt.Println("Tool call streamed")

Output:

Tool call streamed