making progress on openai tool use

Author: sawka

cmd/testai/main-testai.go

@@ -101,9 +101,9 @@ func getToolDefinitions() []uctypes.ToolDefinition {
 }
 
 func testOpenAI(ctx context.Context, model, message string, tools []uctypes.ToolDefinition) {
-	apiKey := os.Getenv("OPENAI_API_KEY")
+	apiKey := os.Getenv("OPENAI_APIKEY")
 	if apiKey == "" {
-		fmt.Println("Error: OPENAI_API_KEY environment variable not set")
+		fmt.Println("Error: OPENAI_APIKEY environment variable not set")
 		os.Exit(1)
 	}
 
@@ -139,9 +139,10 @@ func testOpenAI(ctx context.Context, model, message string, tools []uctypes.Tool
 	defer sseHandler.Close()
 
 	chatOpts := uctypes.WaveChatOpts{
-		ChatId: chatID,
-		Config: *opts,
-		Tools:  tools,
+		ChatId:   chatID,
+		ClientId: uuid.New().String(),
+		Config:   *opts,
+		Tools:    tools,
 	}
 	err := aiusechat.WaveAIPostMessageWrap(ctx, sseHandler, aiMessage, chatOpts)
 	if err != nil {
@@ -150,9 +151,9 @@ func testOpenAI(ctx context.Context, model, message string, tools []uctypes.Tool
 }
 
 func testAnthropic(ctx context.Context, model, message string, tools []uctypes.ToolDefinition) {
-	apiKey := os.Getenv("ANTHROPIC_API_KEY")
+	apiKey := os.Getenv("ANTHROPIC_APIKEY")
 	if apiKey == "" {
-		fmt.Println("Error: ANTHROPIC_API_KEY environment variable not set")
+		fmt.Println("Error: ANTHROPIC_APIKEY environment variable not set")
 		os.Exit(1)
 	}
 
@@ -188,9 +189,10 @@ func testAnthropic(ctx context.Context, model, message string, tools []uctypes.T
 	defer sseHandler.Close()
 
 	chatOpts := uctypes.WaveChatOpts{
-		ChatId: chatID,
-		Config: *opts,
-		Tools:  tools,
+		ChatId:   chatID,
+		ClientId: uuid.New().String(),
+		Config:   *opts,
+		Tools:    tools,
 	}
 	err := aiusechat.WaveAIPostMessageWrap(ctx, sseHandler, aiMessage, chatOpts)
 	if err != nil {
@@ -204,6 +206,12 @@ func testT1(ctx context.Context) {
 	testAnthropic(ctx, "claude-sonnet-4-20250514", "what is 2+2, use the provider adder tool", tools)
 }
 
+func testT2(ctx context.Context) {
+	tool := aiusechat.GetAdderToolDefinition()
+	tools := []uctypes.ToolDefinition{tool}
+	testOpenAI(ctx, "gpt-5", "what is 2+2, use the provider adder tool", tools)
+}
+
 func printUsage() {
 	fmt.Println("Usage: go run main-testai.go [--anthropic] [--tools] [--model <model>] [message]")
 	fmt.Println("Examples:")
@@ -218,18 +226,19 @@ func printUsage() {
 	fmt.Println("  Anthropic: claude-sonnet-4-20250514")
 	fmt.Println("")
 	fmt.Println("Environment variables:")
-	fmt.Println("  OPENAI_API_KEY (for OpenAI models)")
-	fmt.Println("  ANTHROPIC_API_KEY (for Anthropic models)")
+	fmt.Println("  OPENAI_APIKEY (for OpenAI models)")
+	fmt.Println("  ANTHROPIC_APIKEY (for Anthropic models)")
 }
 
 func main() {
-	var anthropic, tools, help, t1 bool
+	var anthropic, tools, help, t1, t2 bool
 	var model string
 	flag.BoolVar(&anthropic, "anthropic", false, "Use Anthropic API instead of OpenAI")
 	flag.BoolVar(&tools, "tools", false, "Enable GitHub Actions Monitor tools for testing")
 	flag.StringVar(&model, "model", "", "AI model to use (defaults: gpt-5 for OpenAI, claude-sonnet-4-20250514 for Anthropic)")
 	flag.BoolVar(&help, "help", false, "Show usage information")
 	flag.BoolVar(&t1, "t1", false, "Run preset T1 test (claude-sonnet-4-20250514 with 'what is 2+2')")
+	flag.BoolVar(&t2, "t2", false, "Run preset T2 test (gpt-5 with 'what is 2+2')")
 	flag.Parse()
 
 	if help {
@@ -244,6 +253,10 @@ func main() {
 		testT1(ctx)
 		return
 	}
+	if t2 {
+		testT2(ctx)
+		return
+	}
 
 	// Set default model based on API type if not provided
 	if model == "" {

cmd/testopenai/main-testopenai.go

@@ -15,10 +15,11 @@ import (
 	"os"
 	"time"
 
+	"github.com/wavetermdev/waveterm/pkg/aiusechat"
 	"github.com/wavetermdev/waveterm/pkg/aiusechat/openai"
 )
 
-func makeOpenAIRequest(ctx context.Context, apiKey, model, message string) error {
+func makeOpenAIRequest(ctx context.Context, apiKey, model, message string, tools bool) error {
 	reqBody := openai.OpenAIRequest{
 		Model: model,
 		Input: []openai.OpenAIMessage{
@@ -36,6 +37,11 @@ func makeOpenAIRequest(ctx context.Context, apiKey, model, message string) error
 		StreamOptions: &openai.StreamOptionsType{IncludeObfuscation: false},
 		Reasoning:     &openai.ReasoningType{Effort: "medium"},
 	}
+	if tools {
+		reqBody.Tools = []openai.OpenAIRequestTool{
+			openai.ConvertToolDefinitionToOpenAI(aiusechat.GetAdderToolDefinition()),
+		}
+	}
 
 	jsonData, err := json.Marshal(reqBody)
 	if err != nil {
@@ -103,10 +109,11 @@ func processSSEStream(reader io.Reader) error {
 }
 
 func printUsage() {
-	fmt.Println("Usage: go run main-testopenai.go [--model <model>] [message]")
+	fmt.Println("Usage: go run main-testopenai.go [--model <model>] [--tools] [message]")
 	fmt.Println("Examples:")
 	fmt.Println("  go run main-testopenai.go 'Stream me a limerick about gophers coding in Go.'")
 	fmt.Println("  go run main-testopenai.go --model gpt-4 'What is 2+2?'")
+	fmt.Println("  go run main-testopenai.go --tools 'What is 2+2? Use the adder tool.'")
 	fmt.Println("")
 	fmt.Println("Default model: gpt-5-mini")
 	fmt.Println("")
@@ -117,9 +124,11 @@ func printUsage() {
 func main() {
 	var model string
 	var showHelp bool
+	var tools bool
 
 	flag.StringVar(&model, "model", "gpt-5-mini", "OpenAI model to use")
 	flag.BoolVar(&showHelp, "help", false, "Show usage information")
+	flag.BoolVar(&tools, "tools", false, "Enable tools for testing")
 	flag.Parse()
 
 	if showHelp {
@@ -148,7 +157,7 @@ func main() {
 	fmt.Printf("Message: %s\n", message)
 	fmt.Println("===")
 
-	if err := makeOpenAIRequest(ctx, apiKey, model, message); err != nil {
+	if err := makeOpenAIRequest(ctx, apiKey, model, message, tools); err != nil {
 		fmt.Printf("Error: %v\n", err)
 		os.Exit(1)
 	}

pkg/aiusechat/anthropic/anthropic-backend.go

@@ -448,79 +448,6 @@ func RunAnthropicChatStep(
 	return stopReason, rtnMessage, nil
 }
 
-// returns (nil, err) before we start streaming
-// returns (stopReason, nil) after we start streaming
-func StreamAnthropicResponses(
-	ctx context.Context,
-	sse *sse.SSEHandlerCh,
-	opts *uctypes.AIOptsType,
-	messages []uctypes.UIMessage,
-	tools []uctypes.ToolDefinition,
-	cont *uctypes.WaveContinueResponse,
-) (*uctypes.WaveStopReason, error) {
-	if sse == nil {
-		return nil, errors.New("sse handler is nil")
-	}
-	// Context with timeout if provided.
-	if opts.TimeoutMs > 0 {
-		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, time.Duration(opts.TimeoutMs)*time.Millisecond)
-		defer cancel()
-	}
-
-	// Convert UIMessages to anthropicInputMessages
-	var anthropicMsgs []anthropicInputMessage
-	for _, m := range messages {
-		aim := anthropicInputMessage{Role: m.Role}
-		blocks, err := convertPartsToAnthropicBlocks(m.Parts, m.Role)
-		if err != nil {
-			return nil, fmt.Errorf("invalid message parts: %w", err)
-		}
-		aim.Content = blocks
-		anthropicMsgs = append(anthropicMsgs, aim)
-	}
-
-	req, err := buildAnthropicHTTPRequest(ctx, anthropicMsgs, uctypes.WaveChatOpts{Config: *opts, Tools: tools})
-	if err != nil {
-		return nil, err
-	}
-
-	httpClient := &http.Client{
-		Timeout: 0, // rely on ctx; streaming can be long
-	}
-	// Proxy support
-	if opts.ProxyURL != "" {
-		pURL, perr := url.Parse(opts.ProxyURL)
-		if perr != nil {
-			return nil, fmt.Errorf("invalid proxy URL: %w", perr)
-		}
-		httpClient.Transport = &http.Transport{
-			Proxy: http.ProxyURL(pURL),
-		}
-	}
-
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	ct := resp.Header.Get("Content-Type")
-	if resp.StatusCode != http.StatusOK || !strings.HasPrefix(ct, "text/event-stream") {
-		return nil, parseAnthropicHTTPError(resp)
-	}
-
-	// At this point we have a valid SSE stream, so setup SSE handling
-	// From here on, errors must be returned through the SSE stream
-	sse.SetupSSE()
-
-	// Use eventsource decoder for proper SSE parsing
-	decoder := eventsource.NewDecoder(resp.Body)
-
-	stopReason, _ := handleAnthropicStreamingResp(ctx, sse, decoder, cont)
-	return stopReason, nil
-}
-
 // handleAnthropicStreamingResp processes the SSE stream after HTTP setup is complete
 func handleAnthropicStreamingResp(
 	ctx context.Context,

pkg/aiusechat/anthropic/anthropic-convertmessage.go

@@ -18,8 +18,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/pkg/aiusechat/uctypes"
 	"github.com/wavetermdev/waveterm/pkg/util/utilfn"
-	"github.com/wavetermdev/waveterm/pkg/waveobj"
-	"github.com/wavetermdev/waveterm/pkg/wstore"
 )
 
 // these conversions are based off the anthropic spec
@@ -31,6 +29,9 @@ func buildAnthropicHTTPRequest(ctx context.Context, msgs []anthropicInputMessage
 	if opts.Model == "" {
 		return nil, errors.New("opts.model is required")
 	}
+	if chatOpts.ClientId == "" {
+		return nil, errors.New("chatOpts.ClientId is required")
+	}
 
 	// Set defaults
 	endpoint := opts.BaseURL
@@ -135,18 +136,13 @@ func buildAnthropicHTTPRequest(ctx context.Context, msgs []anthropicInputMessage
 	if err != nil {
 		return nil, err
 	}
-	client, err := wstore.DBGetSingleton[*waveobj.Client](ctx)
-	if err != nil {
-		return nil, fmt.Errorf("error getting client for Wave AI request: %w", err)
-	}
-
 	req.Header.Set("content-type", "application/json")
 	if opts.APIToken != "" {
 		req.Header.Set("x-api-key", opts.APIToken)
 	}
 	req.Header.Set("anthropic-version", apiVersion)
 	req.Header.Set("accept", "text/event-stream")
-	req.Header.Set("X-Wave-ClientId", client.OID)
+	req.Header.Set("X-Wave-ClientId", chatOpts.ClientId)
 	req.Header.Set("X-Wave-APIType", "anthropic")
 
 	return req, nil