xonecas.io
62159
Sy

symb / commit 8503a98

fix: opencode gpt models

xonecas2026-02-16 8503a9812545ad1ecad4cf4809b33fb6ef367e73 parent 7462b8e

4 files changed

config.toml+2−6
@@ -7,37 +7,33 @@ default_provider = "zen-codex"
77 [providers.ollama-qwen]
88 endpoint = "http://localhost:11434"
99 model = "qwen3:8b"
10-temperature = 0.2
10+#temperature = 0.2
1111
1212 [providers.ollama-qwen-small]
1313 endpoint = "http://localhost:11434"
1414 model = "qwen3:4b"
15-temperature = 0.2
15+#temperature = 0.2
1616
1717 # OpenCode Zen providers (cloud)
1818 [providers.zen-nano]
1919 endpoint = "https://opencode.ai/zen/v1"
2020 model = "gpt-5-nano"
2121 api_key_name = "opencode_zen"
22-temperature = 0.2
2322
2423 [providers.zen-pickle]
2524 endpoint = "https://opencode.ai/zen/v1"
2625 model = "big-pickle"
2726 api_key_name = "opencode_zen"
28-temperature = 0.2
2927
3028 [providers.zen-codex]
3129 endpoint = "https://opencode.ai/zen/v1"
3230 model = "gpt-5.2-codex"
3331 api_key_name = "opencode_zen"
34-temperature = 0.2
3532
3633 [providers.zen-opus]
3734 endpoint = "https://opencode.ai/zen/v1"
3835 model = "claude-opus-4-6"
3936 api_key_name = "opencode_zen"
40-temperature = 0.2
4137
4238 [mcp]
4339 upstream = ""
internal/llm/loop.go+1−1
@@ -81,7 +81,7 @@ func emitAssistant(opts *ProcessTurnOptions, resp *provider.ChatResponse) {
8181 // It streams events via OnDelta and emits complete messages via OnMessage.
8282 func ProcessTurn(ctx context.Context, opts ProcessTurnOptions) error {
8383 if opts.MaxToolRounds == 0 {
84- opts.MaxToolRounds = 40
84+ opts.MaxToolRounds = 60
8585 }
8686
8787 // Convert MCP tools to provider format once
internal/provider/openai_common.go+313−0
@@ -250,6 +250,319 @@ func trySend(ctx context.Context, ch chan<- StreamEvent, evt StreamEvent) bool {
250250 }
251251 }
252252
253+// --- OpenAI Responses API types ---
254+
255+// responsesRequest is the request body for POST /responses.
256+type responsesRequest struct {
257+ Model string `json:"model"`
258+ Input []responsesInputItem `json:"input"`
259+ Tools []responsesToolParam `json:"tools,omitempty"`
260+ Temperature *float32 `json:"temperature,omitempty"`
261+ Stream bool `json:"stream"`
262+}
263+
264+// responsesInputItem is a polymorphic input item (message or function_call_output).
265+type responsesInputItem struct {
266+ Type string `json:"type"` // "message" or "function_call_output"
267+ Role string `json:"role,omitempty"` // for messages: "system", "user", "assistant", "developer"
268+ Content any `json:"content,omitempty"` // string or []responsesContentPart
269+ // function_call_output fields
270+ CallID string `json:"call_id,omitempty"`
271+ Output string `json:"output,omitempty"`
272+}
273+
274+// responsesToolParam defines a function tool for the Responses API.
275+type responsesToolParam struct {
276+ Type string `json:"type"` // "function"
277+ Name string `json:"name"`
278+ Description string `json:"description,omitempty"`
279+ Parameters json.RawMessage `json:"parameters"`
280+}
281+
282+// SSE event types we care about from the Responses API stream.
283+type responsesOutputTextDelta struct {
284+ Delta string `json:"delta"`
285+}
286+
287+type responsesOutputItemAdded struct {
288+ OutputIndex int `json:"output_index"`
289+ Item responsesOutputItemInfo `json:"item"`
290+}
291+
292+type responsesOutputItemInfo struct {
293+ ID string `json:"id"`
294+ Type string `json:"type"` // "message", "function_call", "reasoning"
295+ Name string `json:"name,omitempty"`
296+ CallID string `json:"call_id,omitempty"`
297+}
298+
299+type responsesFuncCallArgsDelta struct {
300+ OutputIndex int `json:"output_index"`
301+ Delta string `json:"delta"`
302+}
303+
304+type responsesReasoningDelta struct {
305+ Delta string `json:"delta"`
306+}
307+
308+type responsesCompleted struct {
309+ Response struct {
310+ Usage *struct {
311+ InputTokens int `json:"input_tokens"`
312+ OutputTokens int `json:"output_tokens"`
313+ } `json:"usage,omitempty"`
314+ } `json:"response"`
315+}
316+
317+type responsesFailed struct {
318+ Response struct {
319+ Error struct {
320+ Code string `json:"code"`
321+ Message string `json:"message"`
322+ } `json:"error"`
323+ } `json:"response"`
324+}
325+
326+// toResponsesInput converts provider-agnostic messages to Responses API input items.
327+func toResponsesInput(messages []Message) []responsesInputItem {
328+ var items []responsesInputItem
329+ for _, m := range messages {
330+ switch m.Role {
331+ case "tool":
332+ items = append(items, responsesInputItem{
333+ Type: "function_call_output",
334+ CallID: m.ToolCallID,
335+ Output: m.Content,
336+ })
337+ case "assistant":
338+ if len(m.ToolCalls) > 0 {
339+ // Emit assistant text as a message, then each tool call as a function_call item.
340+ if m.Content != "" {
341+ items = append(items, responsesInputItem{
342+ Type: "message",
343+ Role: "assistant",
344+ Content: m.Content,
345+ })
346+ }
347+ for _, tc := range m.ToolCalls {
348+ items = append(items, responsesInputItem{
349+ Type: "function_call",
350+ CallID: tc.ID,
351+ // Encode the name and arguments so the API can match them.
352+ Output: string(tc.Arguments),
353+ })
354+ }
355+ continue
356+ }
357+ items = append(items, responsesInputItem{
358+ Type: "message",
359+ Role: "assistant",
360+ Content: m.Content,
361+ })
362+ case roleSystem:
363+ items = append(items, responsesInputItem{
364+ Type: "message",
365+ Role: "developer",
366+ Content: m.Content,
367+ })
368+ default:
369+ items = append(items, responsesInputItem{
370+ Type: "message",
371+ Role: m.Role,
372+ Content: m.Content,
373+ })
374+ }
375+ }
376+ return items
377+}
378+
379+// toResponsesTools converts provider-agnostic tools to Responses API tool format.
380+func toResponsesTools(tools []Tool) []responsesToolParam {
381+ if tools == nil {
382+ return nil
383+ }
384+ emptyParams := json.RawMessage(`{"type":"object","properties":{}}`)
385+ result := make([]responsesToolParam, len(tools))
386+ for i, t := range tools {
387+ params := t.Parameters
388+ if len(params) == 0 {
389+ params = emptyParams
390+ }
391+ result[i] = responsesToolParam{
392+ Type: "function",
393+ Name: t.Name,
394+ Description: t.Description,
395+ Parameters: params,
396+ }
397+ }
398+ return result
399+}
400+
401+// responsesTracker maps Responses API output indices to sequential tool call indices.
402+type responsesTracker struct {
403+ toolCallCount int
404+ outputToToolIdx map[int]int
405+}
406+
407+func newResponsesTracker() *responsesTracker {
408+ return &responsesTracker{outputToToolIdx: make(map[int]int)}
409+}
410+
411+// parseResponsesSSEStream reads Responses API SSE events and emits StreamEvents.
412+//
413+// The Responses API SSE format uses typed events:
414+//
415+// event: response.output_text.delta
416+// data: {"delta":"hello"}
417+func parseResponsesSSEStream(ctx context.Context, reader io.Reader, ch chan<- StreamEvent) {
418+ scanner := bufio.NewScanner(reader)
419+ scanner.Buffer(make([]byte, 0, 64*1024), 512*1024)
420+
421+ rt := newResponsesTracker()
422+ var currentEventType string
423+
424+ for scanner.Scan() {
425+ line := scanner.Text()
426+
427+ if strings.HasPrefix(line, "event: ") {
428+ currentEventType = strings.TrimPrefix(line, "event: ")
429+ continue
430+ }
431+ if !strings.HasPrefix(line, "data: ") {
432+ continue
433+ }
434+ data := strings.TrimPrefix(line, "data: ")
435+
436+ done, stop := rt.handleResponsesEvent(ctx, ch, currentEventType, data)
437+ if done || stop {
438+ return
439+ }
440+ currentEventType = ""
441+ }
442+
443+ if err := scanner.Err(); err != nil {
444+ trySend(ctx, ch, StreamEvent{Type: EventError, Err: err})
445+ return
446+ }
447+ trySend(ctx, ch, StreamEvent{Type: EventDone})
448+}
449+
450+// handleResponsesEvent dispatches a single Responses API SSE event.
451+// Returns (done, stop): done=true means the stream ended normally or with error,
452+// stop=true means ctx was cancelled.
453+func (rt *responsesTracker) handleResponsesEvent(ctx context.Context, ch chan<- StreamEvent, eventType, data string) (bool, bool) {
454+ switch eventType {
455+ case "response.output_text.delta":
456+ return false, !rt.handleTextDelta(ctx, ch, data)
457+ case "response.reasoning_summary_text.delta":
458+ return false, !rt.handleReasoningDelta(ctx, ch, data)
459+ case "response.output_item.added":
460+ return false, !rt.handleOutputItemAdded(ctx, ch, data)
461+ case "response.function_call_arguments.delta":
462+ return false, !rt.handleFuncCallDelta(ctx, ch, data)
463+ case "response.completed":
464+ rt.handleCompleted(ctx, ch, data)
465+ return true, false
466+ case "response.failed":
467+ rt.handleFailed(ctx, ch, data)
468+ return true, false
469+ case "response.incomplete":
470+ trySend(ctx, ch, StreamEvent{Type: EventDone})
471+ return true, false
472+ }
473+ return false, false
474+}
475+
476+func (rt *responsesTracker) handleTextDelta(ctx context.Context, ch chan<- StreamEvent, data string) bool {
477+ var evt responsesOutputTextDelta
478+ if err := json.Unmarshal([]byte(data), &evt); err != nil {
479+ log.Warn().Err(err).Msg("Failed to parse responses output_text.delta")
480+ return true
481+ }
482+ if evt.Delta != "" {
483+ return trySend(ctx, ch, StreamEvent{Type: EventContentDelta, Content: evt.Delta})
484+ }
485+ return true
486+}
487+
488+func (rt *responsesTracker) handleReasoningDelta(ctx context.Context, ch chan<- StreamEvent, data string) bool {
489+ var evt responsesReasoningDelta
490+ if err := json.Unmarshal([]byte(data), &evt); err != nil {
491+ log.Warn().Err(err).Msg("Failed to parse responses reasoning delta")
492+ return true
493+ }
494+ if evt.Delta != "" {
495+ return trySend(ctx, ch, StreamEvent{Type: EventReasoningDelta, Content: evt.Delta})
496+ }
497+ return true
498+}
499+
500+func (rt *responsesTracker) handleOutputItemAdded(ctx context.Context, ch chan<- StreamEvent, data string) bool {
501+ var evt responsesOutputItemAdded
502+ if err := json.Unmarshal([]byte(data), &evt); err != nil {
503+ log.Warn().Err(err).Msg("Failed to parse responses output_item.added")
504+ return true
505+ }
506+ if evt.Item.Type == "function_call" {
507+ idx := rt.toolCallCount
508+ rt.toolCallCount++
509+ rt.outputToToolIdx[evt.OutputIndex] = idx
510+ return trySend(ctx, ch, StreamEvent{
511+ Type: EventToolCallBegin,
512+ ToolCallIndex: idx,
513+ ToolCallID: evt.Item.CallID,
514+ ToolCallName: evt.Item.Name,
515+ })
516+ }
517+ return true
518+}
519+
520+func (rt *responsesTracker) handleFuncCallDelta(ctx context.Context, ch chan<- StreamEvent, data string) bool {
521+ var evt responsesFuncCallArgsDelta
522+ if err := json.Unmarshal([]byte(data), &evt); err != nil {
523+ log.Warn().Err(err).Msg("Failed to parse responses function_call_arguments.delta")
524+ return true
525+ }
526+ if evt.Delta != "" {
527+ idx := rt.outputToToolIdx[evt.OutputIndex]
528+ return trySend(ctx, ch, StreamEvent{
529+ Type: EventToolCallDelta,
530+ ToolCallIndex: idx,
531+ ToolCallArgs: evt.Delta,
532+ })
533+ }
534+ return true
535+}
536+
537+func (rt *responsesTracker) handleCompleted(ctx context.Context, ch chan<- StreamEvent, data string) {
538+ var evt responsesCompleted
539+ if err := json.Unmarshal([]byte(data), &evt); err != nil {
540+ log.Warn().Err(err).Msg("Failed to parse responses completed")
541+ trySend(ctx, ch, StreamEvent{Type: EventDone})
542+ return
543+ }
544+ if evt.Response.Usage != nil {
545+ trySend(ctx, ch, StreamEvent{
546+ Type: EventUsage,
547+ InputTokens: evt.Response.Usage.InputTokens,
548+ OutputTokens: evt.Response.Usage.OutputTokens,
549+ })
550+ }
551+ trySend(ctx, ch, StreamEvent{Type: EventDone})
552+}
553+
554+func (rt *responsesTracker) handleFailed(ctx context.Context, ch chan<- StreamEvent, data string) {
555+ var evt responsesFailed
556+ if err := json.Unmarshal([]byte(data), &evt); err != nil {
557+ trySend(ctx, ch, StreamEvent{Type: EventError, Err: fmt.Errorf("responses stream failed")})
558+ return
559+ }
560+ trySend(ctx, ch, StreamEvent{
561+ Type: EventError,
562+ Err: fmt.Errorf("responses API error %s: %s", evt.Response.Error.Code, evt.Response.Error.Message),
563+ })
564+}
565+
253566 // toOpenAIMessages converts provider-agnostic messages to OpenAI SDK message format.
254567 func toOpenAIMessages(messages []Message) []openai.ChatCompletionMessage {
255568 result := make([]openai.ChatCompletionMessage, len(messages))
internal/provider/opencode.go+42−4
@@ -39,10 +39,7 @@ const (
3939
4040 // opencodeModelEndpoints overrides the prefix-based fallback in opencodeEndpointForModel.
4141 // Only list models whose endpoint differs from what the prefix logic would choose.
42-var opencodeModelEndpoints = map[string]string{
43- // gpt-5-nano uses /chat/completions despite the gpt- prefix (/responses gives 500 errors)
44- "gpt-5-nano": opencodeChatCompletionsEndpoint,
45-}
42+var opencodeModelEndpoints = map[string]string{}
4643
4744 // NewOpenCode creates a new OpenCode Zen provider.
4845 func NewOpenCode(endpoint, model, apiKey string) *OpenCodeProvider {
@@ -76,6 +73,8 @@ func (p *OpenCodeProvider) ChatStream(ctx context.Context, messages []Message, t
7673 return p.chatStreamAnthropic(ctx, messages, tools)
7774 case opencodeChatCompletionsEndpoint:
7875 return p.chatStreamOpenAI(ctx, messages, tools)
76+ case opencodeResponsesEndpoint:
77+ return p.chatStreamResponses(ctx, messages, tools)
7978 default:
8079 return nil, fmt.Errorf("opencode model %q uses unsupported endpoint %q", p.model, endpoint)
8180 }
@@ -167,6 +166,45 @@ func (p *OpenCodeProvider) chatStreamAnthropic(ctx context.Context, messages []M
167166 return ch, nil
168167 }
169168
169+// chatStreamResponses streams via the OpenAI Responses API /responses endpoint.
170+func (p *OpenCodeProvider) chatStreamResponses(ctx context.Context, messages []Message, tools []Tool) (<-chan StreamEvent, error) {
171+ req := responsesRequest{
172+ Model: p.model,
173+ Input: toResponsesInput(messages),
174+ Tools: toResponsesTools(tools),
175+ Stream: true,
176+ }
177+ if !strings.Contains(p.model, "codex") {
178+ t := float32(p.temperature)
179+ req.Temperature = &t
180+ }
181+ body, err := json.Marshal(req)
182+ if err != nil {
183+ return nil, err
184+ }
185+
186+ reader, err := httpDoSSE(ctx, httpRequestConfig{
187+ client: p.httpClient,
188+ url: p.baseURL + opencodeResponsesEndpoint,
189+ body: body,
190+ headers: p.authHeaders(),
191+ provider: p.name,
192+ model: p.model,
193+ })
194+ if err != nil {
195+ return nil, err
196+ }
197+
198+ ch := make(chan StreamEvent)
199+ go func() {
200+ defer close(ch)
201+ defer reader.Close()
202+ parseResponsesSSEStream(ctx, reader, ch)
203+ }()
204+
205+ return ch, nil
206+}
207+
170208 // authHeaders returns common auth headers for requests.
171209 func (p *OpenCodeProvider) authHeaders() map[string]string {
172210 headers := make(map[string]string)