Merge pull request #109 from baalimago/feat/openai-reponses-api

Seems like OpenAI doesn't release new gpt models anymore, just codex models.  This PR adds support for
their responses API, required for their codex models.

Recommendation is to _not_ use `gpt-5.3-codex` as this one for some reason is abysmal at calling tools
 (in my limited testing). `gpt-5.2-codex` works pretty well though.

Author: baalimago

internal/text/generic/stream_completer_mcp_toolcall_test.go

@@ -0,0 +1,60 @@
+package generic
+
+import (
+	"testing"
+
+	"github.com/baalimago/clai/internal/models"
+	"github.com/baalimago/clai/internal/tools"
+	pub_models "github.com/baalimago/clai/pkg/text/models"
+)
+
+type fakeTool struct{ spec pub_models.Specification }
+
+func (f fakeTool) Call(input pub_models.Input) (string, error) { return "", nil }
+func (f fakeTool) Specification() pub_models.Specification     { return f.spec }
+
+// Validates that streamed OpenAI-style tool_calls are assembled, parsed as JSON,
+// and emitted as a pub_models.Call.
+func TestStreamCompleter_EmitsToolCall(t *testing.T) {
+	s := &StreamCompleter{}
+
+	orig := tools.Registry
+	tools.Registry = tools.NewRegistry()
+	defer func() { tools.Registry = orig }()
+
+	tools.Registry.Set("mcp_everything_get-annotated-message", fakeTool{spec: pub_models.Specification{Name: "mcp_everything_get-annotated-message"}})
+
+	// Stream args in multiple chunks, like the real API does.
+	first := Choice{Delta: Delta{ToolCalls: []ToolsCall{{
+		ID:    "id1",
+		Index: 0,
+		Type:  "function",
+		Function: Func{
+			Name:      "mcp_everything_get-annotated-message",
+			Arguments: `{"messageType":"`,
+		},
+	}}}}
+	ev := s.handleChoice(first)
+	if _, ok := ev.(models.NoopEvent); !ok {
+		t.Fatalf("expected NoopEvent, got %T: %#v", ev, ev)
+	}
+
+	second := Choice{Delta: Delta{ToolCalls: []ToolsCall{{Function: Func{Arguments: `debug"`}}}}}
+	ev = s.handleChoice(second)
+	if _, ok := ev.(models.NoopEvent); !ok {
+		t.Fatalf("expected NoopEvent, got %T: %#v", ev, ev)
+	}
+
+	third := Choice{Delta: Delta{ToolCalls: []ToolsCall{{Function: Func{Arguments: `}`}}}}}
+	ev = s.handleChoice(third)
+	call, ok := ev.(pub_models.Call)
+	if !ok {
+		t.Fatalf("expected Call, got %T: %#v", ev, ev)
+	}
+	if call.Name != "mcp_everything_get-annotated-message" {
+		t.Fatalf("unexpected tool name: %q", call.Name)
+	}
+	if call.Inputs == nil || (*call.Inputs)["messageType"] != "debug" {
+		t.Fatalf("unexpected inputs: %#v", call.Inputs)
+	}
+}

internal/tools/handler.go

@@ -30,6 +30,7 @@ func Init() {
 	Registry.Set(tools.RipGrep.Specification().Name, tools.RipGrep)
 	Registry.Set(tools.Go.Specification().Name, tools.Go)
 	Registry.Set(tools.WriteFile.Specification().Name, tools.WriteFile)
+	Registry.Set(tools.ApplyPatch.Specification().Name, tools.ApplyPatch)
 	Registry.Set(tools.FreetextCmd.Specification().Name, tools.FreetextCmd)
 	Registry.Set(tools.Sed.Specification().Name, tools.Sed)
 	Registry.Set(tools.RowsBetween.Specification().Name, tools.RowsBetween)

internal/tools/registry_test.go

@@ -81,6 +81,20 @@ func TestRegistry_Get(t *testing.T) {
 	}
 }
 
+func TestInitRegistersApplyPatch(t *testing.T) {
+	origRegistry := Registry
+	Registry = NewRegistry()
+	Registry.hasBeenInit = false
+	t.Cleanup(func() {
+		Registry = origRegistry
+	})
+
+	Init()
+	if _, ok := Registry.Get("apply_patch"); !ok {
+		t.Fatalf("expected apply_patch to be registered")
+	}
+}
+
 func TestRegistry_All(t *testing.T) {
 	r := NewRegistry()
 	tool1 := newMockTool("tool1")

internal/tools/registry_test_helpers.go

@@ -0,0 +1,20 @@
+package tools
+
+import (
+	"sync"
+	"testing"
+)
+
+var testRegistryMu sync.Mutex
+
+// WithTestRegistry replaces the global Registry for the duration of the test callback.
+func WithTestRegistry(t *testing.T, fn func()) {
+	t.Helper()
+	testRegistryMu.Lock()
+	t.Cleanup(testRegistryMu.Unlock)
+
+	orig := Registry
+	Registry = NewRegistry()
+	t.Cleanup(func() { Registry = orig })
+	fn()
+}

internal/vendors/openai/constants.go

@@ -1,8 +1,9 @@
 package openai
 
 const (
-	ChatURL  = "https://api.openai.com/v1/chat/completions"
-	PhotoURL = "https://api.openai.com/v1/images/generations"
-	VideoURL = "https://api.openai.com/v1/videos"
-	FilesURL = "https://api.openai.com/v1/files"
+	ChatURL      = "https://api.openai.com/v1/chat/completions"
+	ResponsesURL = "https://api.openai.com/v1/responses"
+	PhotoURL     = "https://api.openai.com/v1/images/generations"
+	VideoURL     = "https://api.openai.com/v1/videos"
+	FilesURL     = "https://api.openai.com/v1/files"
 )

internal/vendors/openai/doc.go

@@ -0,0 +1,14 @@
+// Package openai implements OpenAI vendor integrations (chat, photo, video).
+//
+// Streaming paths:
+//   - Non-Codex models use Chat Completions (/v1/chat/completions).
+//   - Codex-named models (model contains "codex", case-insensitive) use Responses (/v1/responses).
+//
+// Tool calling:
+//   - Chat Completions are normalized via the generic stream completer.
+//   - Responses streaming is parsed directly and emits the same normalized events.
+//
+// Usage accounting:
+//   - Chat Completions uses the generic stream completer token usage.
+//   - Responses sets usage from the responses stream metadata.
+package openai

internal/vendors/openai/gpt.go

@@ -1,10 +1,15 @@
 package openai
 
 import (
+	"context"
 	"fmt"
+	"net/http"
+	"os"
 
+	"github.com/baalimago/clai/internal/models"
 	"github.com/baalimago/clai/internal/text/generic"
 	pub_models "github.com/baalimago/clai/pkg/text/models"
+	"github.com/baalimago/go_away_boilerplate/pkg/misc"
 )
 
 var GptDefault = ChatGPT{
@@ -15,31 +20,114 @@ var GptDefault = ChatGPT{
 }
 
 type ChatGPT struct {
-	generic.StreamCompleter
 	Model            string  `json:"model"`
 	FrequencyPenalty float64 `json:"frequency_penalty"`
 	MaxTokens        *int    `json:"max_tokens"` // Use a pointer to allow null value
 	PresencePenalty  float64 `json:"presence_penalty"`
 	Temperature      float64 `json:"temperature"`
 	TopP             float64 `json:"top_p"`
 	URL              string  `json:"url"`
+
+	apiKey string
+	debug  bool
+
+	tools []pub_models.LLMTool
+	usage *pub_models.Usage
+
+	streamCompleter *generic.StreamCompleter
+	useResponses    bool
 }
 
 func (g *ChatGPT) Setup() error {
-	err := g.StreamCompleter.Setup("OPENAI_API_KEY", ChatURL, "DEBUG_OPENAI")
-	if err != nil {
-		return fmt.Errorf("failed to setup stream completer: %w", err)
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		return fmt.Errorf("openai: missing OPENAI_API_KEY")
 	}
-	g.StreamCompleter.Model = g.Model
-	g.StreamCompleter.FrequencyPenalty = &g.FrequencyPenalty
-	g.StreamCompleter.MaxTokens = g.MaxTokens
-	g.StreamCompleter.Temperature = &g.Temperature
-	g.StreamCompleter.TopP = &g.TopP
-	toolChoice := "auto"
-	g.ToolChoice = &toolChoice
+	g.apiKey = apiKey
+	g.debug = misc.Truthy(os.Getenv("DEBUG_OPENAI"))
+	if g.Model == "" {
+		g.Model = GptDefault.Model
+	}
+	url, useResponses := selectOpenAIURL(g.Model, g.URL)
+	g.URL = url
+	g.useResponses = useResponses
 	return nil
 }
 
 func (g *ChatGPT) RegisterTool(tool pub_models.LLMTool) {
-	g.InternalRegisterTool(tool)
+	g.tools = append(g.tools, tool)
+}
+
+func (g *ChatGPT) TokenUsage() *pub_models.Usage {
+	if g.useResponses {
+		return g.usage
+	}
+	if g.streamCompleter == nil {
+		return nil
+	}
+	return g.streamCompleter.TokenUsage()
+}
+
+func (g *ChatGPT) setUsage(usage *pub_models.Usage) error {
+	g.usage = usage
+	return nil
+}
+
+func (g *ChatGPT) StreamCompletions(ctx context.Context, chat pub_models.Chat) (chan models.CompletionEvent, error) {
+	g.usage = nil
+	url, useResponses := selectOpenAIURL(g.Model, g.URL)
+	g.URL = url
+	g.useResponses = useResponses
+
+	if g.useResponses {
+		toolsMapped := make([]responsesTool, 0, len(g.tools))
+		for _, t := range g.tools {
+			spec := t.Specification()
+			toolsMapped = append(toolsMapped, responsesTool{
+				Type:        "function",
+				Name:        spec.Name,
+				Description: spec.Description,
+				Parameters:  spec.Inputs,
+			})
+		}
+
+		s := &responsesStreamer{
+			apiKey:      g.apiKey,
+			url:         g.URL,
+			model:       g.Model,
+			debug:       g.debug,
+			client:      http.DefaultClient,
+			tools:       toolsMapped,
+			usageSetter: g.setUsage,
+		}
+
+		out, err := s.stream(ctx, chat)
+		if err != nil {
+			return nil, fmt.Errorf("openai responses: stream: %w", err)
+		}
+		return out, nil
+	}
+
+	sc := &generic.StreamCompleter{}
+	if err := sc.Setup("OPENAI_API_KEY", g.URL, "DEBUG_OPENAI"); err != nil {
+		return nil, fmt.Errorf("openai chat: setup stream completer: %w", err)
+	}
+	g.streamCompleter = sc
+	g.streamCompleter.Model = g.Model
+	g.streamCompleter.MaxTokens = g.MaxTokens
+	g.streamCompleter.FrequencyPenalty = &g.FrequencyPenalty
+	g.streamCompleter.PresencePenalty = &g.PresencePenalty
+	g.streamCompleter.Temperature = &g.Temperature
+	g.streamCompleter.TopP = &g.TopP
+	toolChoice := "auto"
+	g.streamCompleter.ToolChoice = &toolChoice
+	for _, tool := range g.tools {
+		g.streamCompleter.InternalRegisterTool(tool)
+	}
+
+	out, err := g.streamCompleter.StreamCompletions(ctx, chat)
+	if err != nil {
+		return nil, fmt.Errorf("openai chat: stream: %w", err)
+	}
+	return out, nil
 }