opencode/picoclaw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(openai_compat): parse longcat markup tool calls

Browse source
This commit is contained in:
Alix-007 2026-03-26 21:16:20 +08:00
parent 463a647a33
commit b224647ab2
2 changed files with 213 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

109
pkg/providers/openai_compat/provider.go
View file

@ -10,6 +10,7 @@ import (
"log"
"net/http"
"net/url"
"regexp"
"strings"
"time"
@ -42,6 +43,13 @@ type Option func(*Provider)
const defaultRequestTimeout = common.DefaultRequestTimeout
var (
longCatToolCallBlockPattern = regexp.MustCompile(`(?is)<longcat_tool_call>(.*?)</longcat_tool_call>`)
longCatArgPattern = regexp.MustCompile(
`(?is)<longcat_arg_key>\s*(.*?)\s*</longcat_arg_key>\s*<longcat_arg_value>\s*(.*?)\s*</longcat_arg_value>`,
)
)
func WithMaxTokensField(maxTokensField string) Option {
return func(p *Provider) {
p.maxTokensField = maxTokensField
@ -194,7 +202,12 @@ func (p *Provider) Chat(
return nil, common.HandleErrorResponse(resp, p.apiBase)
}
return common.ReadAndParseResponse(resp, p.apiBase)
out, err := common.ReadAndParseResponse(resp, p.apiBase)
if err != nil {
return nil, err
}
applyLongCatToolCallFallback(out, p.apiBase)
return out, nil
}
// ChatStream implements streaming via OpenAI-compatible SSE (stream: true).
@ -244,7 +257,7 @@ func (p *Provider) ChatStream(
return nil, common.HandleErrorResponse(resp, p.apiBase)
}
return parseStreamResponse(ctx, resp.Body, onChunk)
return parseStreamResponse(ctx, resp.Body, onChunk, isLongCatAPIBase(p.apiBase))
}
// parseStreamResponse parses an OpenAI-compatible SSE stream.
@ -252,6 +265,7 @@ func parseStreamResponse(
ctx context.Context,
reader io.Reader,
onChunk func(accumulated string),
longCatFallback bool,
) (*LLMResponse, error) {
var textContent strings.Builder
var finishReason string
@ -374,18 +388,98 @@ func parseStreamResponse(
})
}
content := textContent.String()
if longCatFallback && len(toolCalls) == 0 {
if parsedCalls, stripped := parseLongCatToolCalls(content); len(parsedCalls) > 0 {
toolCalls = parsedCalls
content = stripped
finishReason = "tool_calls"
}
}
if finishReason == "" {
finishReason = "stop"
}
return &LLMResponse{
Content: textContent.String(),
Content: content,
ToolCalls: toolCalls,
FinishReason: finishReason,
Usage: usage,
}, nil
}
func applyLongCatToolCallFallback(resp *LLMResponse, apiBase string) {
if resp == nil || len(resp.ToolCalls) > 0 || !isLongCatAPIBase(apiBase) {
return
}
toolCalls, strippedContent := parseLongCatToolCalls(resp.Content)
if len(toolCalls) == 0 {
return
}
resp.ToolCalls = toolCalls
resp.Content = strippedContent
resp.FinishReason = "tool_calls"
}
func parseLongCatToolCalls(content string) ([]ToolCall, string) {
matches := longCatToolCallBlockPattern.FindAllStringSubmatch(content, -1)
if len(matches) == 0 {
return nil, content
}
toolCalls := make([]ToolCall, 0, len(matches))
for _, match := range matches {
if len(match) < 2 {
continue
}
block := strings.TrimSpace(match[1])
if block == "" {
continue
}
toolNameRaw := block
if idx := strings.Index(strings.ToLower(block), "<longcat_arg_key>"); idx >= 0 {
toolNameRaw = block[:idx]
}
nameFields := strings.Fields(strings.TrimSpace(toolNameRaw))
if len(nameFields) == 0 {
continue
}
name := nameFields[0]
args := map[string]any{}
for _, argMatch := range longCatArgPattern.FindAllStringSubmatch(block, -1) {
if len(argMatch) < 3 {
continue
}
key := strings.TrimSpace(argMatch[1])
value := strings.TrimSpace(argMatch[2])
if key != "" {
args[key] = value
}
}
argsJSON, _ := json.Marshal(args)
toolCalls = append(toolCalls, ToolCall{
ID: fmt.Sprintf("longcat_call_%d", len(toolCalls)+1),
Type: "function",
Name: name,
Arguments: args,
Function: &FunctionCall{
Name: name,
Arguments: string(argsJSON),
},
})
}
if len(toolCalls) == 0 {
return nil, content
}
stripped := strings.TrimSpace(longCatToolCallBlockPattern.ReplaceAllString(content, ""))
return toolCalls, stripped
}
func normalizeModel(model, apiBase string) string {
before, after, ok := strings.Cut(model, "/")
if !ok {
@ -433,6 +527,15 @@ func isNativeSearchHost(apiBase string) bool {
return host == "api.openai.com" || strings.HasSuffix(host, ".openai.azure.com")
}
func isLongCatAPIBase(apiBase string) bool {
u, err := url.Parse(apiBase)
if err != nil {
return false
}
host := strings.ToLower(u.Hostname())
return host == "longcat.chat" || strings.HasSuffix(host, ".longcat.chat")
}
// supportsPromptCacheKey reports whether the given API base is known to
// support the prompt_cache_key request field. Currently only OpenAI's own
// API and Azure OpenAI support this. All other OpenAI-compatible providers

107
pkg/providers/openai_compat/provider_test.go
View file

@ -158,6 +158,83 @@ func TestProviderChat_ParsesToolCallsWithObjectArguments(t *testing.T) {
}
}
func TestProviderChat_ParsesLongCatMarkupToolCalls(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
resp := map[string]any{
"choices": []map[string]any{
{
"message": map[string]any{
"content": `<longcat_tool_call>weather <longcat_arg_key>location</longcat_arg_key> <longcat_arg_value>New York, United States</longcat_arg_value></longcat_tool_call>`,
},
"finish_reason": "stop",
},
},
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
p := NewProvider("key", server.URL, "")
p.apiBase = "https://api.longcat.chat/openai"
p.httpClient = &http.Client{
Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
r.URL, _ = url.Parse(server.URL + r.URL.Path)
return http.DefaultTransport.RoundTrip(r)
}),
}
out, err := p.Chat(t.Context(), []Message{{Role: "user", Content: "hi"}}, nil, "longcat/LongCat-Flash-Thinking", nil)
if err != nil {
t.Fatalf("Chat() error = %v", err)
}
if len(out.ToolCalls) != 1 {
t.Fatalf("len(ToolCalls) = %d, want 1", len(out.ToolCalls))
}
if out.ToolCalls[0].Name != "weather" {
t.Fatalf("ToolCalls[0].Name = %q, want weather", out.ToolCalls[0].Name)
}
if out.ToolCalls[0].Arguments["location"] != "New York, United States" {
t.Fatalf("location = %v, want New York, United States", out.ToolCalls[0].Arguments["location"])
}
if out.Content != "" {
t.Fatalf("Content = %q, want empty after stripping longcat tool tag", out.Content)
}
if out.FinishReason != "tool_calls" {
t.Fatalf("FinishReason = %q, want tool_calls", out.FinishReason)
}
}
func TestProviderChat_DoesNotParseLongCatMarkupForOtherHosts(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
resp := map[string]any{
"choices": []map[string]any{
{
"message": map[string]any{
"content": `<longcat_tool_call>weather <longcat_arg_key>location</longcat_arg_key> <longcat_arg_value>Paris</longcat_arg_value></longcat_tool_call>`,
},
"finish_reason": "stop",
},
},
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
p := NewProvider("key", server.URL, "")
out, err := p.Chat(t.Context(), []Message{{Role: "user", Content: "hi"}}, nil, "gpt-4o", nil)
if err != nil {
t.Fatalf("Chat() error = %v", err)
}
if len(out.ToolCalls) != 0 {
t.Fatalf("len(ToolCalls) = %d, want 0 for non-longcat host", len(out.ToolCalls))
}
if !strings.Contains(out.Content, "<longcat_tool_call>") {
t.Fatalf("Content should keep raw markup for non-longcat host, got %q", out.Content)
}
}
func TestProviderChat_ParsesReasoningContent(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
resp := map[string]any{
@ -694,6 +771,36 @@ func TestProviderChat_ExtraBodyOverridesOptions(t *testing.T) {
}
}
func TestParseStreamResponse_LongCatMarkupFallback(t *testing.T) {
stream := strings.Join([]string{
`data: {"choices":[{"delta":{"content":"Please check weather: "}}]}`,
`data: {"choices":[{"delta":{"content":"<longcat_tool_call>weather <longcat_arg_key>location</longcat_arg_key> <longcat_arg_value>Tokyo</longcat_arg_value></longcat_tool_call>"}}]}`,
`data: {"choices":[{"finish_reason":"stop"}]}`,
`data: [DONE]`,
"",
}, "\n")
out, err := parseStreamResponse(t.Context(), strings.NewReader(stream), nil, true)
if err != nil {
t.Fatalf("parseStreamResponse() error = %v", err)
}
if len(out.ToolCalls) != 1 {
t.Fatalf("len(ToolCalls) = %d, want 1", len(out.ToolCalls))
}
if out.ToolCalls[0].Name != "weather" {
t.Fatalf("ToolCalls[0].Name = %q, want weather", out.ToolCalls[0].Name)
}
if out.ToolCalls[0].Arguments["location"] != "Tokyo" {
t.Fatalf("location = %v, want Tokyo", out.ToolCalls[0].Arguments["location"])
}
if out.Content != "Please check weather:" {
t.Fatalf("Content = %q, want %q", out.Content, "Please check weather:")
}
if out.FinishReason != "tool_calls" {
t.Fatalf("FinishReason = %q, want tool_calls", out.FinishReason)
}
}
type roundTripperFunc func(*http.Request) (*http.Response, error)
func (f roundTripperFunc) RoundTrip(r *http.Request) (*http.Response, error) {