Skip to content

Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.

openai: add Codex compaction support (#18224)

Parth Sareen3f77cb6dfb6f
diff --git a/openai/responses.go b/openai/responses.go
index b5a739d2b..c08dd3cb2 100644
--- a/openai/responses.go
+++ b/openai/responses.go
@@ -2,6 +2,7 @@ package openai
import (
"encoding/json"
+ "errors"
"fmt"
"math/rand"
"strings"
@@ -323,6 +324,18 @@ func unmarshalResponsesInputItem(data []byte) (ResponsesInputItem, error) {
return nil, err
}
return call, nil
+ case "compaction":
+ var compaction ResponsesCompactionItem
+ if err := json.Unmarshal(data, &compaction); err != nil {
+ return nil, err
+ }
+ return compaction, nil
+ case "compaction_trigger":
+ var trigger ResponsesCompactionTrigger
+ if err := json.Unmarshal(data, &trigger); err != nil {
+ return nil, err
+ }
+ return trigger, nil
default:
if itemType == "" {
return nil, fmt.Errorf("input item missing required 'type' field")
@@ -594,6 +607,10 @@ func FromResponsesRequest(r ResponsesRequest) (*api.ChatRequest, error) {
case ResponsesWebSearchCall:
// Built-in tool calls are history metadata. The assistant message
// that follows carries the model-visible result of the prior search.
+ case ResponsesCompactionItem:
+ return nil, errors.New("compaction items must be expanded before Responses conversion")
+ case ResponsesCompactionTrigger:
+ return nil, errors.New("compaction_trigger must be handled before Responses conversion")
}
}
diff --git a/openai/responses_compact.go b/openai/responses_compact.go
new file mode 100644
index 000000000..f8c7e9de7
--- /dev/null
+++ b/openai/responses_compact.go
@@ -0,0 +1,699 @@
+package openai
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "strings"
+ "time"
+
+ "github.com/ollama/ollama/api"
+)
+
+const (
+ OllamaCompactionPayloadType = "ollama_compaction"
+ OllamaCompactionPayloadVersion = 1
+ CreateSummaryToolName = "create_summary"
+ compactionSummaryToolName = "ollama_compaction_summary"
+)
+
+// ResponsesCompactionTrigger is the terminal input item sent by current Codex
+// clients when they request remote compaction through POST /v1/responses.
+type ResponsesCompactionTrigger struct {
+ Type string `json:"type"`
+}
+
+func (ResponsesCompactionTrigger) responsesInputItem() {}
+
+// ResponsesCompactionItem is the opaque continuation item understood by Codex.
+// Ollama stores a versioned JSON payload in EncryptedContent; the payload is not
+// encrypted and must be consumed by Ollama before another model request.
+type ResponsesCompactionItem struct {
+ Type string `json:"type"`
+ EncryptedContent string `json:"encrypted_content"`
+}
+
+func (ResponsesCompactionItem) responsesInputItem() {}
+
+// OllamaCompactionPayload is Ollama's stateless continuation format.
+type OllamaCompactionPayload struct {
+ Type string `json:"type"`
+ Version int `json:"version"`
+ Summary string `json:"summary"`
+ Retained []api.Message `json:"retained"`
+}
+
+// CompactionTranscriptItem is one ordered input item shown to the compaction
+// model. Ref is request-local and is the only value the model may select.
+type CompactionTranscriptItem struct {
+ Ref string `json:"ref"`
+ Type string `json:"type"`
+ Message api.Message `json:"message"`
+}
+
+type compactionToolMetadata struct {
+ Name string `json:"name"`
+ Description string `json:"description,omitempty"`
+}
+
+type compactionTranscript struct {
+ Items []CompactionTranscriptItem `json:"items"`
+ Tools []compactionToolMetadata `json:"tools,omitempty"`
+}
+
+type compactionToolGroup struct {
+ CallRef string
+ ResultRef string
+}
+
+// ResponsesCompactionPlan contains the validated, ordered state required to
+// make and verify a compaction-model request.
+type ResponsesCompactionPlan struct {
+ Model string
+ Stream bool
+
+ items []CompactionTranscriptItem
+ tools []compactionToolMetadata
+ groups []compactionToolGroup
+ forcedRefs map[string]struct{}
+}
+
+// ResponsesCompactionResult is the validated result of a compaction-model call.
+type ResponsesCompactionResult struct {
+ Item ResponsesCompactionItem
+ Usage *ResponsesUsage
+}
+
+type summarySelection struct {
+ Summary string `json:"summary"`
+ RetainItemIDs []string `json:"retain_item_ids"`
+}
+
+type rawResponsesRequest struct {
+ Model string `json:"model"`
+ Input json.RawMessage `json:"input"`
+ Stream *bool `json:"stream,omitempty"`
+ Tools []ResponsesTool `json:"tools,omitempty"`
+ Fields map[string]json.RawMessage `json:"-"`
+}
+
+// PrepareTriggeredCompaction recognizes the Codex v2 terminal trigger. It
+// returns requested=false without changing ordinary Responses requests.
+func PrepareTriggeredCompaction(body []byte) (*ResponsesCompactionPlan, bool, error) {
+ req, items, err := decodeRawResponsesRequest(body)
+ if err != nil {
+ return nil, false, err
+ }
+ if len(items) == 0 || rawInputItemType(items[len(items)-1]) != "compaction_trigger" {
+ return nil, false, nil
+ }
+ if req.Stream == nil || !*req.Stream {
+ return nil, true, errors.New("compaction_trigger requires stream=true")
+ }
+ for _, item := range items[:len(items)-1] {
+ if rawInputItemType(item) == "compaction_trigger" {
+ return nil, true, errors.New("compaction_trigger must be the final and only compaction trigger")
+ }
+ }
+
+ items, _, err = expandOllamaCompactionItems(items[:len(items)-1])
+ if err != nil {
+ return nil, true, err
+ }
+ plan, err := newResponsesCompactionPlan(req, items)
+ return plan, true, err
+}
+
+// PrepareStandaloneCompaction validates a POST /v1/responses/compact body.
+func PrepareStandaloneCompaction(body []byte) (*ResponsesCompactionPlan, error) {
+ req, items, err := decodeRawResponsesRequest(body)
+ if err != nil {
+ return nil, err
+ }
+ for _, item := range items {
+ if rawInputItemType(item) == "compaction_trigger" {
+ return nil, errors.New("compaction_trigger is only valid on POST /v1/responses")
+ }
+ }
+ items, _, err = expandOllamaCompactionItems(items)
+ if err != nil {
+ return nil, err
+ }
+ return newResponsesCompactionPlan(req, items)
+}
+
+// ExpandResponsesCompactionInput replaces the newest Ollama compaction item
+// with its summary and retained messages. Items on either side of the
+// compaction item remain in their original order.
+func ExpandResponsesCompactionInput(body []byte) ([]byte, bool, error) {
+ req, items, err := decodeRawResponsesRequest(body)
+ if err != nil {
+ return nil, false, err
+ }
+ items, changed, err := expandOllamaCompactionItems(items)
+ if err != nil || !changed {
+ return body, changed, err
+ }
+
+ input, err := json.Marshal(items)
+ if err != nil {
+ return nil, false, err
+ }
+ req.Fields["input"] = input
+ rewritten, err := json.Marshal(req.Fields)
+ return rewritten, true, err
+}
+
+func decodeRawResponsesRequest(body []byte) (rawResponsesRequest, []json.RawMessage, error) {
+ var fields map[string]json.RawMessage
+ if err := json.Unmarshal(body, &fields); err != nil {
+ return rawResponsesRequest{}, nil, fmt.Errorf("invalid Responses request: %w", err)
+ }
+
+ var req rawResponsesRequest
+ if raw, ok := fields["model"]; !ok || json.Unmarshal(raw, &req.Model) != nil || strings.TrimSpace(req.Model) == "" {
+ return rawResponsesRequest{}, nil, errors.New("model is required")
+ }
+ req.Model = strings.TrimSpace(req.Model)
+ req.Fields = fields
+ req.Input = fields["input"]
+ if raw := fields["stream"]; len(raw) > 0 {
+ if err := json.Unmarshal(raw, &req.Stream); err != nil {
+ return rawResponsesRequest{}, nil, fmt.Errorf("invalid stream value: %w", err)
+ }
+ }
+ if raw := fields["tools"]; len(raw) > 0 {
+ if err := json.Unmarshal(raw, &req.Tools); err != nil {
+ return rawResponsesRequest{}, nil, fmt.Errorf("invalid tools: %w", err)
+ }
+ }
+
+ items, err := decodeRawResponsesInput(req.Input)
+ if err != nil {
+ return rawResponsesRequest{}, nil, err
+ }
+ return req, items, nil
+}
+
+func decodeRawResponsesInput(input json.RawMessage) ([]json.RawMessage, error) {
+ if len(input) == 0 || bytes.Equal(bytes.TrimSpace(input), []byte("null")) {
+ return nil, errors.New("input is required")
+ }
+
+ var text string
+ if err := json.Unmarshal(input, &text); err == nil {
+ item, err := json.Marshal(map[string]any{
+ "type": "message", "role": "user", "content": text,
+ })
+ if err != nil {
+ return nil, err
+ }
+ return []json.RawMessage{item}, nil
+ }
+
+ var items []json.RawMessage
+ if err := json.Unmarshal(input, &items); err != nil {
+ return nil, fmt.Errorf("input must be a string or array: %w", err)
+ }
+ if items == nil {
+ return nil, errors.New("input must be a string or array")
+ }
+ return items, nil
+}
+
+func rawInputItemType(item json.RawMessage) string {
+ var header struct {
+ Type string `json:"type"`
+ Role string `json:"role"`
+ }
+ if json.Unmarshal(item, &header) != nil {
+ return ""
+ }
+ if header.Type == "" && header.Role != "" {
+ return "message"
+ }
+ return header.Type
+}
+
+func expandOllamaCompactionItems(items []json.RawMessage) ([]json.RawMessage, bool, error) {
+ boundary := -1
+ for i := range items {
+ if rawInputItemType(items[i]) == "compaction" {
+ boundary = i
+ }
+ }
+ if boundary < 0 {
+ return items, false, nil
+ }
+
+ payload, err := decodeOllamaCompactionItem(items[boundary])
+ if err != nil {
+ return nil, false, err
+ }
+ expanded, err := payloadToResponsesItems(payload)
+ if err != nil {
+ return nil, false, err
+ }
+ rewritten := make([]json.RawMessage, 0, len(items)-1+len(expanded))
+ rewritten = append(rewritten, items[:boundary]...)
+ rewritten = append(rewritten, expanded...)
+ rewritten = append(rewritten, items[boundary+1:]...)
+ return rewritten, true, nil
+}
+
+func decodeOllamaCompactionItem(item json.RawMessage) (OllamaCompactionPayload, error) {
+ var wire ResponsesCompactionItem
+ if err := json.Unmarshal(item, &wire); err != nil {
+ return OllamaCompactionPayload{}, fmt.Errorf("invalid compaction item: %w", err)
+ }
+ if wire.Type != "compaction" || wire.EncryptedContent == "" {
+ return OllamaCompactionPayload{}, errors.New("invalid compaction item")
+ }
+
+ var payload OllamaCompactionPayload
+ decoder := json.NewDecoder(strings.NewReader(wire.EncryptedContent))
+ decoder.DisallowUnknownFields()
+ if err := decoder.Decode(&payload); err != nil {
+ return OllamaCompactionPayload{}, errors.New("unsupported compaction item: encrypted_content is not an Ollama payload")
+ }
+ if payload.Type != OllamaCompactionPayloadType || payload.Version != OllamaCompactionPayloadVersion {
+ return OllamaCompactionPayload{}, fmt.Errorf("unsupported Ollama compaction payload type or version")
+ }
+ if strings.TrimSpace(payload.Summary) == "" {
+ return OllamaCompactionPayload{}, errors.New("Ollama compaction payload has an empty summary")
+ }
+ if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
+ return OllamaCompactionPayload{}, errors.New("unsupported compaction item: encrypted_content contains more than one JSON value")
+ }
+ return payload, nil
+}
+
+func payloadToResponsesItems(payload OllamaCompactionPayload) ([]json.RawMessage, error) {
+ b, err := json.Marshal(payload)
+ if err != nil {
+ return nil, err
+ }
+ hash := sha256.Sum256(b)
+ callID := "call_ollama_compaction_" + hex.EncodeToString(hash[:6])
+ args, _ := json.Marshal(map[string]any{"version": payload.Version})
+
+ items := make([]json.RawMessage, 0, 2+len(payload.Retained))
+ call, err := json.Marshal(map[string]any{
+ "type": "function_call", "call_id": callID, "name": compactionSummaryToolName, "arguments": string(args),
+ })
+ if err != nil {
+ return nil, err
+ }
+ result, err := json.Marshal(map[string]any{
+ "type": "function_call_output", "call_id": callID, "output": payload.Summary,
+ })
+ if err != nil {
+ return nil, err
+ }
+ items = append(items, call, result)
+ for _, message := range payload.Retained {
+ converted, err := messageToResponsesItems(message)
+ if err != nil {
+ return nil, fmt.Errorf("invalid retained message: %w", err)
+ }
+ items = append(items, converted...)
+ }
+ return items, nil
+}
+
+func messageToResponsesItems(message api.Message) ([]json.RawMessage, error) {
+ if len(message.Images) > 0 {
+ return nil, errors.New("retained images are not supported")
+ }
+
+ var values []any
+ if message.Thinking != "" {
+ values = append(values, map[string]any{
+ "type": "reasoning",
+ "summary": []map[string]string{{"type": "summary_text", "text": message.Thinking}},
+ })
+ }
+ if message.Role == "tool" {
+ if message.ToolCallID == "" {
+ return nil, errors.New("retained tool message is missing tool_call_id")
+ }
+ values = append(values, map[string]any{
+ "type": "function_call_output", "call_id": message.ToolCallID, "output": message.Content,
+ })
+ } else if message.Content != "" || len(message.ToolCalls) == 0 {
+ values = append(values, map[string]any{
+ "type": "message", "role": message.Role, "content": message.Content,
+ })
+ }
+ for _, call := range message.ToolCalls {
+ if call.ID == "" || call.Function.Name == "" {
+ return nil, errors.New("retained function call is missing call_id or name")
+ }
+ arguments, err := json.Marshal(call.Function.Arguments)
+ if err != nil {
+ return nil, err
+ }
+ values = append(values, map[string]any{
+ "type": "function_call", "call_id": call.ID, "name": call.Function.Name, "arguments": string(arguments),
+ })
+ }
+
+ items := make([]json.RawMessage, 0, len(values))
+ for _, value := range values {
+ item, err := json.Marshal(value)
+ if err != nil {
+ return nil, err
+ }
+ items = append(items, item)
+ }
+ return items, nil
+}
+
+func newResponsesCompactionPlan(req rawResponsesRequest, rawItems []json.RawMessage) (*ResponsesCompactionPlan, error) {
+ if len(rawItems) == 0 {
+ return nil, errors.New("compaction input is empty")
+ }
+
+ items := make([]CompactionTranscriptItem, 0, len(rawItems))
+ for i, raw := range rawItems {
+ item, err := unmarshalResponsesInputItem(raw)
+ if err != nil {
+ return nil, fmt.Errorf("input[%d]: %w", i, err)
+ }
+ message, kind, err := compactionMessage(item)
+ if err != nil {
+ return nil, fmt.Errorf("input[%d]: %w", i, err)
+ }
+ if len(message.Images) > 0 {
+ return nil, fmt.Errorf("input[%d]: image inputs are not supported by compaction", i)
+ }
+ items = append(items, CompactionTranscriptItem{
+ Ref: fmt.Sprintf("item_%06d", i+1), Type: kind, Message: message,
+ })
+ }
+
+ groups, forced, err := analyzeCompactionToolState(items)
+ if err != nil {
+ return nil, err
+ }
+ stream := req.Stream != nil && *req.Stream
+ return &ResponsesCompactionPlan{
+ Model: req.Model, Stream: stream, items: items, tools: collectCompactionToolMetadata(req.Tools), groups: groups, forcedRefs: forced,
+ }, nil
+}
+
+func compactionMessage(item ResponsesInputItem) (api.Message, string, error) {
+ switch value := item.(type) {
+ case ResponsesInputMessage:
+ message, err := convertInputMessage(value)
+ return message, "message", err
+ case ResponsesFunctionCall:
+ var arguments api.ToolCallFunctionArguments
+ if value.Arguments != "" {
+ if err := json.Unmarshal([]byte(value.Arguments), &arguments); err != nil {
+ return api.Message{}, "", fmt.Errorf("invalid function arguments: %w", err)
+ }
+ }
+ return api.Message{Role: "assistant", ToolCalls: []api.ToolCall{{
+ ID: value.CallID, Function: api.ToolCallFunction{Name: value.Name, Arguments: arguments},
+ }}}, "function_call", nil
+ case ResponsesFunctionCallOutput:
+ content := value.Output
+ var images []api.ImageData
+ if len(value.OutputItems) > 0 {
+ var err error
+ content, images, err = convertResponsesContent(value.OutputItems)
+ if err != nil {
+ return api.Message{}, "", err
+ }
+ }
+ return api.Message{Role: "tool", Content: content, Images: images, ToolCallID: value.CallID}, "function_call_output", nil
+ case ResponsesReasoningInput:
+ var summary strings.Builder
+ for _, part := range value.Summary {
+ summary.WriteString(part.Text)
+ }
+ thinking := summary.String()
+ if thinking == "" && value.EncryptedContent != "" {
+ thinking = "[opaque reasoning state omitted during Ollama compaction]"
+ }
+ return api.Message{Role: "assistant", Thinking: thinking}, "reasoning", nil
+ case ResponsesCompactionItem, ResponsesCompactionTrigger:
+ return api.Message{}, "", errors.New("unexpected compaction control item")
+ default:
+ return api.Message{}, "", fmt.Errorf("unsupported compaction input type %T", item)
+ }
+}
+
+func analyzeCompactionToolState(items []CompactionTranscriptItem) ([]compactionToolGroup, map[string]struct{}, error) {
+ type pendingGroup struct {
+ callIndex int
+ resultIndex int
+ group compactionToolGroup
+ }
+ byCallID := make(map[string]*pendingGroup)
+ ignoredCallIDs := make(map[string]struct{})
+ var ordered []*pendingGroup
+
+ for i, item := range items {
+ switch item.Type {
+ case "function_call":
+ call := item.Message.ToolCalls[0]
+ if call.ID == "" {
+ return nil, nil, fmt.Errorf("%s: function call is missing call_id", item.Ref)
+ }
+ if call.Function.Name == compactionSummaryToolName && strings.HasPrefix(call.ID, "call_ollama_compaction_") {
+ ignoredCallIDs[call.ID] = struct{}{}
+ continue
+ }
+ if _, exists := byCallID[call.ID]; exists {
+ return nil, nil, fmt.Errorf("%s: duplicate function call_id %q", item.Ref, call.ID)
+ }
+ group := &pendingGroup{callIndex: i, resultIndex: -1, group: compactionToolGroup{CallRef: item.Ref}}
+ byCallID[call.ID] = group
+ ordered = append(ordered, group)
+ case "function_call_output":
+ callID := item.Message.ToolCallID
+ if _, ignored := ignoredCallIDs[callID]; ignored {
+ continue
+ }
+ group := byCallID[callID]
+ if group == nil {
+ return nil, nil, fmt.Errorf("%s: function output has no matching call %q", item.Ref, callID)
+ }
+ if group.resultIndex >= 0 {
+ return nil, nil, fmt.Errorf("%s: duplicate function output for call %q", item.Ref, callID)
+ }
+ group.resultIndex = i
+ group.group.ResultRef = item.Ref
+ }
+ }
+
+ forced := make(map[string]struct{})
+ groups := make([]compactionToolGroup, 0, len(ordered))
+ for _, candidate := range ordered {
+ groups = append(groups, candidate.group)
+ active := candidate.resultIndex < 0
+ if !active {
+ active = true
+ for _, item := range items[candidate.resultIndex+1:] {
+ if item.Type == "reasoning" || item.Type == "function_call" || (item.Type == "message" && item.Message.Role == "assistant") {
+ active = false
+ break
+ }
+ }
+ }
+ if active {
+ forced[candidate.group.CallRef] = struct{}{}
+ if candidate.group.ResultRef != "" {
+ forced[candidate.group.ResultRef] = struct{}{}
+ }
+ }
+ }
+ return groups, forced, nil
+}
+
+func collectCompactionToolMetadata(tools []ResponsesTool) []compactionToolMetadata {
+ var metadata []compactionToolMetadata
+ var add func(prefix string, tools []ResponsesTool)
+ add = func(prefix string, tools []ResponsesTool) {
+ for _, tool := range tools {
+ name := tool.Name
+ if prefix != "" && !strings.HasPrefix(name, prefix+".") {
+ name = prefix + "." + name
+ }
+ if tool.Type == "namespace" {
+ add(name, tool.Tools)
+ continue
+ }
+ description := ""
+ if tool.Description != nil {
+ description = *tool.Description
+ }
+ metadata = append(metadata, compactionToolMetadata{Name: name, Description: description})
+ }
+ }
+ add("", tools)
+ return metadata
+}
+
+// SummaryRequest returns an ordinary non-streaming Responses request. A repair
+// request includes the validation error from the first model response.
+func (p *ResponsesCompactionPlan) SummaryRequest(repairError string) ([]byte, error) {
+ // TODO(compaction): enforce the 40% retained-context target after the
+ // selected model's prompt renderer and token budget are available here.
+ transcript, err := json.Marshal(compactionTranscript{Items: p.items, Tools: p.tools})
+ if err != nil {
+ return nil, err
+ }
+ prompt := `Summarize the conversation for another coding agent. Preserve the goal, decisions, constraints, repository state, changed files, test results, failures, active work, and next actions. Use retain_item_ids only for exact source items that cannot safely be paraphrased. Tool calls and results are execution state; do not invent or edit them. Call create_summary exactly once.`
+ if repairError != "" {
+ prompt += " Your previous create_summary call was invalid: " + repairError + ". Return one corrected create_summary call."
+ }
+
+ description := "Return the compact summary and the exact input item references that must remain verbatim."
+ strict := true
+ request := map[string]any{
+ "model": p.Model,
+ "input": []any{
+ map[string]any{"type": "message", "role": "system", "content": prompt},
+ map[string]any{"type": "message", "role": "user", "content": string(transcript)},
+ },
+ "tools": []ResponsesTool{{
+ Type: "function", Name: CreateSummaryToolName, Description: &description, Strict: &strict,
+ Parameters: map[string]any{
+ "type": "object",
+ "properties": map[string]any{
+ "summary": map[string]any{"type": "string"},
+ "retain_item_ids": map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
+ },
+ "required": []string{"summary", "retain_item_ids"},
+ "additionalProperties": false,
+ },
+ }},
+ "tool_choice": map[string]any{"type": "function", "name": CreateSummaryToolName},
+ "parallel_tool_calls": false,
+ "store": false,
+ "stream": false,
+ }
+ return json.Marshal(request)
+}
+
+// Complete validates create_summary and builds the stateless continuation.
+func (p *ResponsesCompactionPlan) Complete(body []byte) (ResponsesCompactionResult, error) {
+ var response ResponsesResponse
+ if err := json.Unmarshal(body, &response); err != nil {
+ return ResponsesCompactionResult{}, fmt.Errorf("invalid summary response: %w", err)
+ }
+
+ var calls []ResponsesOutputItem
+ for _, item := range response.Output {
+ if item.Type == "function_call" && item.Name == CreateSummaryToolName {
+ calls = append(calls, item)
+ }
+ }
+ if len(calls) != 1 {
+ return ResponsesCompactionResult{}, fmt.Errorf("expected one %s call, got %d", CreateSummaryToolName, len(calls))
+ }
+
+ var selection summarySelection
+ if err := json.Unmarshal([]byte(calls[0].Arguments), &selection); err != nil {
+ return ResponsesCompactionResult{}, fmt.Errorf("invalid %s arguments: %w", CreateSummaryToolName, err)
+ }
+ selection.Summary = strings.TrimSpace(selection.Summary)
+ if selection.Summary == "" {
+ return ResponsesCompactionResult{}, errors.New("create_summary returned an empty summary")
+ }
+
+ known := make(map[string]struct{}, len(p.items))
+ for _, item := range p.items {
+ known[item.Ref] = struct{}{}
+ }
+ selected := make(map[string]struct{}, len(selection.RetainItemIDs)+len(p.forcedRefs))
+ for _, ref := range selection.RetainItemIDs {
+ if _, ok := known[ref]; !ok {
+ return ResponsesCompactionResult{}, fmt.Errorf("create_summary selected unknown item %q", ref)
+ }
+ if _, duplicate := selected[ref]; duplicate {
+ return ResponsesCompactionResult{}, fmt.Errorf("create_summary selected duplicate item %q", ref)
+ }
+ selected[ref] = struct{}{}
+ }
+ for ref := range p.forcedRefs {
+ selected[ref] = struct{}{}
+ }
+ for _, group := range p.groups {
+ _, callSelected := selected[group.CallRef]
+ _, resultSelected := selected[group.ResultRef]
+ if callSelected || resultSelected {
+ selected[group.CallRef] = struct{}{}
+ if group.ResultRef != "" {
+ selected[group.ResultRef] = struct{}{}
+ }
+ }
+ }
+
+ retained := make([]api.Message, 0, len(selected))
+ for _, item := range p.items {
+ if _, ok := selected[item.Ref]; ok {
+ retained = append(retained, item.Message)
+ }
+ }
+ payload := OllamaCompactionPayload{
+ Type: OllamaCompactionPayloadType, Version: OllamaCompactionPayloadVersion, Summary: selection.Summary, Retained: retained,
+ }
+ payloadJSON, err := json.Marshal(payload)
+ if err != nil {
+ return ResponsesCompactionResult{}, err
+ }
+ return ResponsesCompactionResult{
+ Item: ResponsesCompactionItem{Type: "compaction", EncryptedContent: string(payloadJSON)}, Usage: response.Usage,
+ }, nil
+}
+
+// ResponsesCompactedResponse is returned by POST /v1/responses/compact.
+type ResponsesCompactedResponse struct {
+ ID string `json:"id"`
+ Object string `json:"object"`
+ CreatedAt int64 `json:"created_at"`
+ Output []ResponsesCompactionItem `json:"output"`
+ Usage *ResponsesUsage `json:"usage"`
+}
+
+// NewResponsesCompactedResponse builds the standalone compact response.
+func NewResponsesCompactedResponse(id string, result ResponsesCompactionResult) ResponsesCompactedResponse {
+ return ResponsesCompactedResponse{
+ ID: id, Object: "response.compaction", CreatedAt: time.Now().Unix(), Output: []ResponsesCompactionItem{result.Item}, Usage: result.Usage,
+ }
+}
+
+// NewResponsesCompactionStreamEvents builds the Codex v2 stream. Codex uses
+// output_item.done and requires exactly one compaction item before completed.
+func NewResponsesCompactionStreamEvents(id, model string, result ResponsesCompactionResult) []ResponsesStreamEvent {
+ converter := NewResponsesStreamConverter(id, "", model, ResponsesRequest{Model: model})
+ created := converter.buildResponseObject("in_progress", []any{}, nil)
+ completedUsage := map[string]any(nil)
+ if result.Usage != nil {
+ completedUsage = map[string]any{
+ "input_tokens": result.Usage.InputTokens,
+ "output_tokens": result.Usage.OutputTokens,
+ "total_tokens": result.Usage.TotalTokens,
+ "input_tokens_details": result.Usage.InputTokensDetails,
+ "output_tokens_details": result.Usage.OutputTokensDetails,
+ }
+ }
+ completed := converter.buildResponseObject("completed", []any{result.Item}, completedUsage)
+ completed["completed_at"] = time.Now().Unix()
+
+ return []ResponsesStreamEvent{
+ converter.newEvent("response.created", map[string]any{"response": created}),
+ converter.newEvent("response.in_progress", map[string]any{"response": created}),
+ converter.newEvent("response.output_item.added", map[string]any{"output_index": 0, "item": result.Item}),
+ converter.newEvent("response.output_item.done", map[string]any{"output_index": 0, "item": result.Item}),
+ converter.newEvent("response.completed", map[string]any{"response": completed}),
+ }
+}
diff --git a/openai/responses_compact_test.go b/openai/responses_compact_test.go
new file mode 100644
index 000000000..eb08c35e5
--- /dev/null
+++ b/openai/responses_compact_test.go
@@ -0,0 +1,313 @@
+package openai
+
+import (
+ "encoding/json"
+ "strings"
+ "testing"
+
+ "github.com/ollama/ollama/api"
+)
+
+func compactionResponseBody(t *testing.T, selection map[string]any) []byte {
+ t.Helper()
+ arguments, err := json.Marshal(selection)
+ if err != nil {
+ t.Fatal(err)
+ }
+ body, err := json.Marshal(map[string]any{
+ "id": "resp_summary",
+ "object": "response",
+ "status": "completed",
+ "output": []any{map[string]any{
+ "id": "fc_summary", "type": "function_call", "status": "completed",
+ "call_id": "call_summary", "name": CreateSummaryToolName, "arguments": string(arguments),
+ }},
+ "usage": map[string]any{"input_tokens": 100, "output_tokens": 20, "total_tokens": 120},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ return body
+}
+
+func decodeResultPayload(t *testing.T, result ResponsesCompactionResult) OllamaCompactionPayload {
+ t.Helper()
+ item, err := json.Marshal(result.Item)
+ if err != nil {
+ t.Fatal(err)
+ }
+ payload, err := decodeOllamaCompactionItem(item)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return payload
+}
+
+func TestPrepareTriggeredCompactionBuildsSummaryRequest(t *testing.T) {
+ description := "Read a file"
+ body := []byte(`{
+ "model":"qwen3:4b",
+ "stream":true,
+ "instructions":"do not send this to the compactor",
+ "tools":[{"type":"function","name":"read_file","description":"Read a file","strict":false,"parameters":{"type":"object"}}],
+ "input":[
+ {"type":"message","role":"user","content":"inspect main.go"},
+ {"type":"function_call","call_id":"call_1","name":"read_file","arguments":"{\"path\":\"main.go\"}"},
+ {"type":"function_call_output","call_id":"call_1","output":"package main"},
+ {"type":"compaction_trigger"}
+ ]
+ }`)
+
+ plan, requested, err := PrepareTriggeredCompaction(body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !requested {
+ t.Fatal("expected compaction request")
+ }
+ if plan.Model != "qwen3:4b" || !plan.Stream {
+ t.Fatalf("unexpected plan: model=%q stream=%v", plan.Model, plan.Stream)
+ }
+
+ requestBody, err := plan.SummaryRequest("")
+ if err != nil {
+ t.Fatal(err)
+ }
+ var request struct {
+ Input []struct {
+ Role string `json:"role"`
+ Content string `json:"content"`
+ } `json:"input"`
+ Tools []ResponsesTool `json:"tools"`
+ Instructions string `json:"instructions"`
+ Stream bool `json:"stream"`
+ }
+ if err := json.Unmarshal(requestBody, &request); err != nil {
+ t.Fatal(err)
+ }
+ if request.Stream {
+ t.Fatal("summary inference must be non-streaming")
+ }
+ if request.Instructions != "" {
+ t.Fatalf("original instructions leaked into summary request: %q", request.Instructions)
+ }
+ if len(request.Tools) != 1 || request.Tools[0].Name != CreateSummaryToolName {
+ t.Fatalf("unexpected callable tools: %+v", request.Tools)
+ }
+ if len(request.Input) != 2 || !strings.Contains(request.Input[1].Content, description) || !strings.Contains(request.Input[1].Content, "read_file") {
+ t.Fatalf("summary transcript is missing tool metadata: %+v", request.Input)
+ }
+ if strings.Contains(request.Input[1].Content, `"instructions"`) {
+ t.Fatalf("original instructions leaked into transcript: %s", request.Input[1].Content)
+ }
+
+ result, err := plan.Complete(compactionResponseBody(t, map[string]any{
+ "summary": "Continue inspecting main.go.", "retain_item_ids": []string{},
+ }))
+ if err != nil {
+ t.Fatal(err)
+ }
+ payload := decodeResultPayload(t, result)
+ if payload.Summary != "Continue inspecting main.go." {
+ t.Fatalf("unexpected summary: %q", payload.Summary)
+ }
+ if len(payload.Retained) != 2 {
+ t.Fatalf("expected active call and result to be forced, got %+v", payload.Retained)
+ }
+ if payload.Retained[0].ToolCalls[0].ID != "call_1" || payload.Retained[1].ToolCallID != "call_1" {
+ t.Fatalf("tool state was not retained in order: %+v", payload.Retained)
+ }
+}
+
+func TestPrepareTriggeredCompactionRequiresStreaming(t *testing.T) {
+ body := []byte(`{"model":"test","input":[{"type":"message","role":"user","content":"hi"},{"type":"compaction_trigger"}]}`)
+ _, requested, err := PrepareTriggeredCompaction(body)
+ if !requested || err == nil || !strings.Contains(err.Error(), "stream=true") {
+ t.Fatalf("requested=%v err=%v", requested, err)
+ }
+}
+
+func TestCompactionSelectionKeepsCompleteToolGroupInOriginalOrder(t *testing.T) {
+ body := []byte(`{
+ "model":"test",
+ "stream":true,
+ "input":[
+ {"type":"message","role":"user","content":"run it"},
+ {"type":"function_call","call_id":"call_1","name":"shell","arguments":"{}"},
+ {"type":"function_call_output","call_id":"call_1","output":"ok"},
+ {"type":"message","role":"assistant","content":"done"},
+ {"type":"compaction_trigger"}
+ ]
+ }`)
+ plan, requested, err := PrepareTriggeredCompaction(body)
+ if err != nil || !requested {
+ t.Fatalf("prepare: requested=%v err=%v", requested, err)
+ }
+
+ result, err := plan.Complete(compactionResponseBody(t, map[string]any{
+ "summary": "The command completed.", "retain_item_ids": []string{"item_000003"},
+ }))
+ if err != nil {
+ t.Fatal(err)
+ }
+ payload := decodeResultPayload(t, result)
+ if len(payload.Retained) != 2 {
+ t.Fatalf("expected complete tool group, got %+v", payload.Retained)
+ }
+ if len(payload.Retained[0].ToolCalls) != 1 || payload.Retained[1].Role != "tool" {
+ t.Fatalf("tool group order changed: %+v", payload.Retained)
+ }
+}
+
+func TestCompactionRejectsInvalidToolStateAndSelections(t *testing.T) {
+ t.Run("orphan result", func(t *testing.T) {
+ body := []byte(`{"model":"test","stream":true,"input":[{"type":"function_call_output","call_id":"missing","output":"x"},{"type":"compaction_trigger"}]}`)
+ _, requested, err := PrepareTriggeredCompaction(body)
+ if !requested || err == nil || !strings.Contains(err.Error(), "no matching call") {
+ t.Fatalf("requested=%v err=%v", requested, err)
+ }
+ })
+
+ t.Run("unknown ref", func(t *testing.T) {
+ body := []byte(`{"model":"test","stream":true,"input":[{"type":"message","role":"user","content":"hi"},{"type":"compaction_trigger"}]}`)
+ plan, _, err := PrepareTriggeredCompaction(body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, err = plan.Complete(compactionResponseBody(t, map[string]any{
+ "summary": "hi", "retain_item_ids": []string{"missing"},
+ }))
+ if err == nil || !strings.Contains(err.Error(), "unknown item") {
+ t.Fatalf("expected unknown item error, got %v", err)
+ }
+ })
+}
+
+func TestExpandResponsesCompactionInputPreservesCodexRetainedPrefix(t *testing.T) {
+ payload := OllamaCompactionPayload{
+ Type: OllamaCompactionPayloadType, Version: OllamaCompactionPayloadVersion,
+ Summary: "The user chose option A.",
+ Retained: []api.Message{{Role: "assistant", ToolCalls: []api.ToolCall{{
+ ID: "call_live", Function: api.ToolCallFunction{Name: "shell", Arguments: api.NewToolCallFunctionArguments()},
+ }}}},
+ }
+ payloadJSON, err := json.Marshal(payload)
+ if err != nil {
+ t.Fatal(err)
+ }
+ body, err := json.Marshal(map[string]any{
+ "model": "test",
+ "input": []any{
+ map[string]any{"type": "message", "role": "user", "content": "first user turn retained by Codex"},
+ map[string]any{"type": "message", "role": "user", "content": "second user turn retained by Codex"},
+ ResponsesCompactionItem{Type: "compaction", EncryptedContent: string(payloadJSON)},
+ map[string]any{"type": "message", "role": "user", "content": "new turn"},
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rewritten, changed, err := ExpandResponsesCompactionInput(body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !changed {
+ t.Fatal("expected rewritten input")
+ }
+ var request struct {
+ Input []json.RawMessage `json:"input"`
+ }
+ if err := json.Unmarshal(rewritten, &request); err != nil {
+ t.Fatal(err)
+ }
+ if len(request.Input) != 6 {
+ t.Fatalf("expected retained prefix, summary pair, retained call, and new turn; got %s", rewritten)
+ }
+ var types []string
+ for _, item := range request.Input {
+ types = append(types, rawInputItemType(item))
+ }
+ want := []string{"message", "message", "function_call", "function_call_output", "function_call", "message"}
+ for i := range want {
+ if types[i] != want[i] {
+ t.Fatalf("types=%v want=%v", types, want)
+ }
+ }
+ for _, marker := range []string{"first user turn retained by Codex", "second user turn retained by Codex"} {
+ if strings.Count(string(rewritten), marker) != 1 {
+ t.Fatalf("retained user message %q was lost or duplicated: %s", marker, rewritten)
+ }
+ }
+ if !strings.Contains(string(rewritten), "new turn") {
+ t.Fatalf("post-boundary input was lost: %s", rewritten)
+ }
+}
+
+func TestExpandResponsesCompactionInputRejectsForeignPayload(t *testing.T) {
+ body := []byte(`{"model":"test","input":[{"type":"compaction","encrypted_content":"opaque-provider-state"}]}`)
+ _, changed, err := ExpandResponsesCompactionInput(body)
+ if changed || err == nil || !strings.Contains(err.Error(), "not an Ollama payload") {
+ t.Fatalf("changed=%v err=%v", changed, err)
+ }
+}
+
+func TestRepeatedCompactionReplacesRatherThanNestsPayload(t *testing.T) {
+ oldPayload, err := json.Marshal(OllamaCompactionPayload{
+ Type: OllamaCompactionPayloadType, Version: OllamaCompactionPayloadVersion, Summary: "old summary",
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ body, err := json.Marshal(map[string]any{
+ "model": "test", "stream": true,
+ "input": []any{
+ map[string]any{"type": "message", "role": "user", "content": "retained prefix"},
+ ResponsesCompactionItem{Type: "compaction", EncryptedContent: string(oldPayload)},
+ map[string]any{"type": "message", "role": "user", "content": "new work"},
+ ResponsesCompactionTrigger{Type: "compaction_trigger"},
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ plan, requested, err := PrepareTriggeredCompaction(body)
+ if err != nil || !requested {
+ t.Fatalf("prepare: requested=%v err=%v", requested, err)
+ }
+ result, err := plan.Complete(compactionResponseBody(t, map[string]any{
+ "summary": "replacement summary", "retain_item_ids": []string{},
+ }))
+ if err != nil {
+ t.Fatal(err)
+ }
+ payload := decodeResultPayload(t, result)
+ if len(payload.Retained) != 0 {
+ t.Fatalf("old synthetic summary pair was retained: %+v", payload.Retained)
+ }
+ if strings.Contains(result.Item.EncryptedContent, "old summary") || strings.Contains(result.Item.EncryptedContent, "retained prefix") {
+ t.Fatalf("old compaction was nested: %s", result.Item.EncryptedContent)
+ }
+}
+
+func TestCompactionStreamContainsExactlyOneCompletedItem(t *testing.T) {
+ result := ResponsesCompactionResult{Item: ResponsesCompactionItem{Type: "compaction", EncryptedContent: `{"type":"ollama_compaction","version":1}`}}
+ events := NewResponsesCompactionStreamEvents("resp_1", "test", result)
+ var done, completed int
+ for _, event := range events {
+ switch event.Event {
+ case "response.output_item.done":
+ done++
+ data := event.Data.(map[string]any)
+ item := data["item"].(ResponsesCompactionItem)
+ if item.Type != "compaction" {
+ t.Fatalf("unexpected item: %+v", item)
+ }
+ case "response.completed":
+ completed++
+ }
+ }
+ if done != 1 || completed != 1 {
+ t.Fatalf("done=%d completed=%d events=%+v", done, completed, events)
+ }
+}
diff --git a/server/responses_compact.go b/server/responses_compact.go
new file mode 100644
index 000000000..8aae4d334
--- /dev/null
+++ b/server/responses_compact.go
@@ -0,0 +1,219 @@
+package server
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "strconv"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ "github.com/klauspost/compress/zstd"
+
+ "github.com/ollama/ollama/middleware"
+ "github.com/ollama/ollama/openai"
+)
+
+// responsesCompactionMiddleware intercepts only Codex compaction control items.
+// Ordinary Responses requests continue through the existing route unchanged.
+func (s *Server) responsesCompactionMiddleware() gin.HandlerFunc {
+ return func(c *gin.Context) {
+ body, err := readResponsesCompactionBody(c)
+ if err != nil {
+ writeResponsesCompactionError(c, http.StatusBadRequest, "invalid_request_error", err.Error())
+ return
+ }
+
+ plan, requested, err := openai.PrepareTriggeredCompaction(body)
+ if err != nil {
+ writeResponsesCompactionError(c, http.StatusBadRequest, "invalid_request_error", err.Error())
+ return
+ }
+ if requested {
+ c.Abort()
+ s.handleResponsesCompaction(c, plan, true)
+ return
+ }
+
+ rewritten, changed, err := openai.ExpandResponsesCompactionInput(body)
+ if err != nil {
+ writeResponsesCompactionError(c, http.StatusBadRequest, "invalid_request_error", err.Error())
+ return
+ }
+ if changed {
+ resetResponsesRequestBody(c.Request, rewritten)
+ }
+ c.Next()
+ }
+}
+
+// ResponsesCompactHandler implements POST /v1/responses/compact with an
+// Ollama-owned ordinary inference request rather than upstream passthrough.
+func (s *Server) ResponsesCompactHandler(c *gin.Context) {
+ body, err := readResponsesCompactionBody(c)
+ if err != nil {
+ writeResponsesCompactionError(c, http.StatusBadRequest, "invalid_request_error", err.Error())
+ return
+ }
+ plan, err := openai.PrepareStandaloneCompaction(body)
+ if err != nil {
+ writeResponsesCompactionError(c, http.StatusBadRequest, "invalid_request_error", err.Error())
+ return
+ }
+ s.handleResponsesCompaction(c, plan, false)
+}
+
+func readResponsesCompactionBody(c *gin.Context) ([]byte, error) {
+ if c.GetHeader("Content-Encoding") == "zstd" {
+ reader, err := zstd.NewReader(c.Request.Body, zstd.WithDecoderMaxMemory(8<<20))
+ if err != nil {
+ return nil, fmt.Errorf("failed to decompress zstd body")
+ }
+ decompressed, err := io.ReadAll(http.MaxBytesReader(c.Writer, io.NopCloser(reader), maxDecompressedBodySize))
+ reader.Close()
+ if err != nil {
+ return nil, err
+ }
+ c.Request.Header.Del("Content-Encoding")
+ resetResponsesRequestBody(c.Request, decompressed)
+ }
+
+ body, err := readRequestBody(c.Request)
+ if err != nil {
+ return nil, err
+ }
+ if len(bytes.TrimSpace(body)) == 0 {
+ return nil, fmt.Errorf("missing request body")
+ }
+ return body, nil
+}
+
+func resetResponsesRequestBody(r *http.Request, body []byte) {
+ r.Body = io.NopCloser(bytes.NewReader(body))
+ r.ContentLength = int64(len(body))
+ r.Header.Set("Content-Length", strconv.Itoa(len(body)))
+}
+
+func (s *Server) handleResponsesCompaction(c *gin.Context, plan *openai.ResponsesCompactionPlan, stream bool) {
+ var validationErr error
+ for range 2 {
+ repair := ""
+ if validationErr != nil {
+ repair = validationErr.Error()
+ }
+ request, err := plan.SummaryRequest(repair)
+ if err != nil {
+ writeResponsesCompactionError(c, http.StatusInternalServerError, "compaction_failed", "compaction failed; the original conversation is unchanged")
+ return
+ }
+
+ response := s.runResponsesCompactionInference(c, request)
+ if response.status < http.StatusOK || response.status >= http.StatusMultipleChoices {
+ copyResponsesCompactionResponse(c, response)
+ return
+ }
+
+ result, err := plan.Complete(response.body.Bytes())
+ if err != nil {
+ validationErr = err
+ continue
+ }
+
+ id := fmt.Sprintf("resp_compact_%d", time.Now().UnixNano())
+ if stream {
+ writeResponsesCompactionStream(c, openai.NewResponsesCompactionStreamEvents(id, plan.Model, result))
+ return
+ }
+ c.JSON(http.StatusOK, openai.NewResponsesCompactedResponse(id, result))
+ return
+ }
+
+ writeResponsesCompactionError(c, http.StatusInternalServerError, "compaction_failed", "compaction failed; the selected model did not return a valid summary and the original conversation is unchanged")
+}
+
+// runResponsesCompactionInference uses the normal Responses stack without the
+// compaction dispatcher. This keeps local and cloud model selection identical
+// to an ordinary request and permits one isolated repair retry.
+func (s *Server) runResponsesCompactionInference(c *gin.Context, body []byte) *responsesInferenceRecorder {
+ router := gin.New()
+ router.POST("/v1/responses",
+ cloudPassthroughMiddleware(cloudErrRemoteInferenceUnavailable),
+ middleware.ResponsesMiddleware(),
+ s.ChatHandler,
+ )
+
+ req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodPost, "/v1/responses", bytes.NewReader(body))
+ if err != nil {
+ return &responsesInferenceRecorder{header: make(http.Header), status: http.StatusInternalServerError, body: *bytes.NewBufferString(err.Error())}
+ }
+ req.Header = c.Request.Header.Clone()
+ req.Header.Del("Content-Encoding")
+ req.Header.Set("Content-Type", "application/json")
+ req.ContentLength = int64(len(body))
+
+ recorder := &responsesInferenceRecorder{header: make(http.Header)}
+ router.ServeHTTP(recorder, req)
+ return recorder
+}
+
+type responsesInferenceRecorder struct {
+ header http.Header
+ body bytes.Buffer
+ status int
+}
+
+func (r *responsesInferenceRecorder) Header() http.Header {
+ return r.header
+}
+
+func (r *responsesInferenceRecorder) WriteHeader(status int) {
+ if r.status == 0 {
+ r.status = status
+ }
+}
+
+func (r *responsesInferenceRecorder) Write(data []byte) (int, error) {
+ if r.status == 0 {
+ r.status = http.StatusOK
+ }
+ return r.body.Write(data)
+}
+
+func (r *responsesInferenceRecorder) Flush() {}
+
+func copyResponsesCompactionResponse(c *gin.Context, response *responsesInferenceRecorder) {
+ for key, values := range response.header {
+ if key == "Content-Length" {
+ continue
+ }
+ for _, value := range values {
+ c.Header(key, value)
+ }
+ }
+ c.Data(response.status, response.header.Get("Content-Type"), response.body.Bytes())
+}
+
+func writeResponsesCompactionStream(c *gin.Context, events []openai.ResponsesStreamEvent) {
+ c.Header("Content-Type", "text/event-stream")
+ c.Header("Cache-Control", "no-cache")
+ c.Header("Connection", "keep-alive")
+ c.Status(http.StatusOK)
+ for _, event := range events {
+ data, err := json.Marshal(event.Data)
+ if err != nil {
+ return
+ }
+ _, _ = fmt.Fprintf(c.Writer, "event: %s\ndata: %s\n\n", event.Event, data)
+ }
+ if flusher, ok := c.Writer.(http.Flusher); ok {
+ flusher.Flush()
+ }
+}
+
+func writeResponsesCompactionError(c *gin.Context, status int, code, message string) {
+ response := openai.NewError(status, message)
+ response.Error.Code = &code
+ c.AbortWithStatusJSON(status, response)
+}
diff --git a/server/responses_compact_test.go b/server/responses_compact_test.go
new file mode 100644
index 000000000..02d654419
--- /dev/null
+++ b/server/responses_compact_test.go
@@ -0,0 +1,282 @@
+package server
+
+import (
+ "bytes"
+ "encoding/json"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+
+ "github.com/ollama/ollama/openai"
+)
+
+func summaryResponse(t *testing.T, summary string, retained []string) []byte {
+ t.Helper()
+ arguments, err := json.Marshal(map[string]any{"summary": summary, "retain_item_ids": retained})
+ if err != nil {
+ t.Fatal(err)
+ }
+ body, err := json.Marshal(map[string]any{
+ "id": "resp_summary", "object": "response", "status": "completed", "model": "fixture",
+ "output": []any{map[string]any{
+ "id": "fc_summary", "type": "function_call", "status": "completed", "call_id": "call_summary",
+ "name": openai.CreateSummaryToolName, "arguments": string(arguments),
+ }},
+ "usage": map[string]any{
+ "input_tokens": 100, "output_tokens": 20, "total_tokens": 120,
+ "input_tokens_details": map[string]any{"cached_tokens": 0},
+ "output_tokens_details": map[string]any{"reasoning_tokens": 0},
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ return body
+}
+
+type compactionUpstreamCapture struct {
+ mu sync.Mutex
+ paths []string
+ bodies [][]byte
+}
+
+func (c *compactionUpstreamCapture) add(path string, body []byte) int {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+ c.paths = append(c.paths, path)
+ c.bodies = append(c.bodies, append([]byte(nil), body...))
+ return len(c.bodies)
+}
+
+func (c *compactionUpstreamCapture) snapshot() ([]string, [][]byte) {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+ paths := append([]string(nil), c.paths...)
+ bodies := make([][]byte, len(c.bodies))
+ for i := range c.bodies {
+ bodies[i] = append([]byte(nil), c.bodies[i]...)
+ }
+ return paths, bodies
+}
+
+func newCompactionTestServer(t *testing.T, handler func(int, http.ResponseWriter, *http.Request, []byte)) (*httptest.Server, *compactionUpstreamCapture) {
+ t.Helper()
+ gin.SetMode(gin.TestMode)
+ setTestHome(t, t.TempDir())
+
+ capture := &compactionUpstreamCapture{}
+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ body, _ := io.ReadAll(r.Body)
+ attempt := capture.add(r.URL.Path, body)
+ handler(attempt, w, r, body)
+ }))
+ t.Cleanup(upstream.Close)
+
+ original := cloudProxyBaseURL
+ cloudProxyBaseURL = upstream.URL
+ t.Cleanup(func() { cloudProxyBaseURL = original })
+
+ s := &Server{}
+ router, err := s.GenerateRoutes()
+ if err != nil {
+ t.Fatal(err)
+ }
+ local := httptest.NewServer(router)
+ t.Cleanup(local.Close)
+ return local, capture
+}
+
+func postCompactionRequest(t *testing.T, server *httptest.Server, path, body string) (int, http.Header, []byte) {
+ t.Helper()
+ req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, server.URL+path, strings.NewReader(body))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+ response, err := server.Client().Do(req)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer response.Body.Close()
+ responseBody, err := io.ReadAll(response.Body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return response.StatusCode, response.Header.Clone(), responseBody
+}
+
+func TestResponsesCompactUsesOrdinarySelectedCloudModel(t *testing.T) {
+ local, capture := newCompactionTestServer(t, func(_ int, w http.ResponseWriter, _ *http.Request, _ []byte) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write(summaryResponse(t, "Continue the task.", nil))
+ })
+
+ status, _, body := postCompactionRequest(t, local, "/v1/responses/compact", `{
+ "model":"fixture:cloud",
+ "instructions":"original agent instructions",
+ "input":[{"type":"message","role":"user","content":"hello"}],
+ "tools":[{"type":"function","name":"shell","description":"Run a command","strict":false,"parameters":{"type":"object"}}]
+ }`)
+ if status != http.StatusOK {
+ t.Fatalf("status=%d body=%s", status, body)
+ }
+ var compacted openai.ResponsesCompactedResponse
+ if err := json.Unmarshal(body, &compacted); err != nil {
+ t.Fatal(err)
+ }
+ if compacted.Object != "response.compaction" || len(compacted.Output) != 1 || compacted.Output[0].Type != "compaction" {
+ t.Fatalf("unexpected compact response: %+v", compacted)
+ }
+
+ paths, bodies := capture.snapshot()
+ if len(paths) != 1 || paths[0] != "/v1/responses" {
+ t.Fatalf("compaction must use one ordinary Responses inference call, paths=%v", paths)
+ }
+ if bytes.Contains(bodies[0], []byte("original agent instructions")) {
+ t.Fatalf("top-level instructions leaked to compactor: %s", bodies[0])
+ }
+ var summaryRequest struct {
+ Model string `json:"model"`
+ Stream bool `json:"stream"`
+ Tools []openai.ResponsesTool `json:"tools"`
+ }
+ if err := json.Unmarshal(bodies[0], &summaryRequest); err != nil {
+ t.Fatal(err)
+ }
+ if summaryRequest.Model != "fixture" || summaryRequest.Stream {
+ t.Fatalf("unexpected upstream summary request: %+v", summaryRequest)
+ }
+ if len(summaryRequest.Tools) != 1 || summaryRequest.Tools[0].Name != openai.CreateSummaryToolName {
+ t.Fatalf("unexpected callable tools: %+v", summaryRequest.Tools)
+ }
+ if !bytes.Contains(bodies[0], []byte("shell")) {
+ t.Fatalf("original tool metadata missing from transcript: %s", bodies[0])
+ }
+}
+
+func TestResponsesCompactionTriggerReturnsCodexStream(t *testing.T) {
+ local, capture := newCompactionTestServer(t, func(_ int, w http.ResponseWriter, _ *http.Request, _ []byte) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write(summaryResponse(t, "Compact summary.", nil))
+ })
+
+ status, header, body := postCompactionRequest(t, local, "/v1/responses", `{
+ "model":"fixture:cloud","stream":true,
+ "input":[{"type":"message","role":"user","content":"hello"},{"type":"compaction_trigger"}]
+ }`)
+ if status != http.StatusOK {
+ t.Fatalf("status=%d body=%s", status, body)
+ }
+ if got := header.Get("Content-Type"); !strings.HasPrefix(got, "text/event-stream") {
+ t.Fatalf("content-type=%q", got)
+ }
+ text := string(body)
+ if strings.Count(text, "event: response.output_item.done") != 1 || strings.Count(text, `"type":"compaction"`) == 0 {
+ t.Fatalf("missing single compaction output item: %s", text)
+ }
+ if strings.Count(text, "event: response.completed") != 1 {
+ t.Fatalf("missing response.completed: %s", text)
+ }
+ paths, requests := capture.snapshot()
+ if len(paths) != 1 || paths[0] != "/v1/responses" {
+ t.Fatalf("paths=%v requests=%s", paths, requests)
+ }
+}
+
+func TestResponsesCompactionRepairsMalformedSummaryOnce(t *testing.T) {
+ local, capture := newCompactionTestServer(t, func(attempt int, w http.ResponseWriter, _ *http.Request, _ []byte) {
+ w.Header().Set("Content-Type", "application/json")
+ if attempt == 1 {
+ _, _ = w.Write([]byte(`{"id":"bad","object":"response","output":[{"type":"message","role":"assistant","content":[]}]}`))
+ return
+ }
+ _, _ = w.Write(summaryResponse(t, "Repaired summary.", nil))
+ })
+
+ status, _, body := postCompactionRequest(t, local, "/v1/responses/compact", `{"model":"fixture:cloud","input":"hello"}`)
+ if status != http.StatusOK {
+ t.Fatalf("status=%d body=%s", status, body)
+ }
+ _, bodies := capture.snapshot()
+ if len(bodies) != 2 {
+ t.Fatalf("expected one repair retry, got %d requests", len(bodies))
+ }
+ if !bytes.Contains(bodies[1], []byte("previous create_summary call was invalid")) {
+ t.Fatalf("repair request does not explain the validation error: %s", bodies[1])
+ }
+}
+
+func TestResponsesCompactionFailsAfterOneRepair(t *testing.T) {
+ local, capture := newCompactionTestServer(t, func(_ int, w http.ResponseWriter, _ *http.Request, _ []byte) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"id":"bad","object":"response","output":[]}`))
+ })
+
+ status, _, body := postCompactionRequest(t, local, "/v1/responses/compact", `{"model":"fixture:cloud","input":"hello"}`)
+ if status != http.StatusInternalServerError {
+ t.Fatalf("status=%d body=%s", status, body)
+ }
+ var errorResponse openai.ErrorResponse
+ if err := json.Unmarshal(body, &errorResponse); err != nil {
+ t.Fatal(err)
+ }
+ if errorResponse.Error.Code == nil || *errorResponse.Error.Code != "compaction_failed" {
+ t.Fatalf("unexpected error: %+v", errorResponse)
+ }
+ paths, _ := capture.snapshot()
+ if len(paths) != 2 {
+ t.Fatalf("expected exactly two attempts, got %d", len(paths))
+ }
+}
+
+func TestResponsesCompactionPayloadIsExpandedBeforeCloudPassthrough(t *testing.T) {
+ local, capture := newCompactionTestServer(t, func(_ int, w http.ResponseWriter, _ *http.Request, _ []byte) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"id":"resp_next","object":"response","status":"completed","model":"fixture","output":[],"usage":null}`))
+ })
+ payload, err := json.Marshal(openai.OllamaCompactionPayload{
+ Type: openai.OllamaCompactionPayloadType, Version: openai.OllamaCompactionPayloadVersion,
+ Summary: "The build is ready.",
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ request, err := json.Marshal(map[string]any{
+ "model": "fixture:cloud", "stream": false,
+ "input": []any{
+ map[string]any{"type": "message", "role": "user", "content": "first retained user turn"},
+ map[string]any{"type": "message", "role": "user", "content": "second retained user turn"},
+ openai.ResponsesCompactionItem{Type: "compaction", EncryptedContent: string(payload)},
+ map[string]any{"type": "message", "role": "user", "content": "new turn"},
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ status, _, body := postCompactionRequest(t, local, "/v1/responses", string(request))
+ if status != http.StatusOK {
+ t.Fatalf("status=%d body=%s", status, body)
+ }
+ paths, bodies := capture.snapshot()
+ if len(paths) != 1 || paths[0] != "/v1/responses" {
+ t.Fatalf("paths=%v", paths)
+ }
+ forwarded := string(bodies[0])
+ if strings.Contains(forwarded, `"type":"compaction"`) {
+ t.Fatalf("compaction boundary was forwarded: %s", forwarded)
+ }
+ for _, marker := range []string{"first retained user turn", "second retained user turn"} {
+ if strings.Count(forwarded, marker) != 1 {
+ t.Fatalf("retained user message %q was lost or duplicated: %s", marker, forwarded)
+ }
+ }
+ if !strings.Contains(forwarded, "The build is ready.") || !strings.Contains(forwarded, "new turn") || !strings.Contains(forwarded, "ollama_compaction_summary") {
+ t.Fatalf("expanded state is incomplete: %s", forwarded)
+ }
+}
diff --git a/server/routes.go b/server/routes.go
index 263c7e27a..63a889761 100644
--- a/server/routes.go
+++ b/server/routes.go
@@ -1922,7 +1922,8 @@ func (s *Server) GenerateRoutes() (http.Handler, error) {
r.POST("/v1/embeddings", cloudPassthroughMiddleware(cloudErrRemoteInferenceUnavailable), middleware.EmbeddingsMiddleware(), s.EmbedHandler)
r.GET("/v1/models", middleware.ListMiddleware(), s.ListHandler)
r.GET("/v1/models/:model", cloudModelPathPassthroughMiddleware(cloudErrRemoteModelDetailsUnavailable), middleware.RetrieveMiddleware(), s.ShowHandler)
- r.POST("/v1/responses", s.withInferenceRequestLogging("/v1/responses", cloudPassthroughMiddleware(cloudErrRemoteInferenceUnavailable), middleware.ResponsesMiddleware(), s.ChatHandler)...)
+ r.POST("/v1/responses", s.withInferenceRequestLogging("/v1/responses", s.responsesCompactionMiddleware(), cloudPassthroughMiddleware(cloudErrRemoteInferenceUnavailable), middleware.ResponsesMiddleware(), s.ChatHandler)...)
+ r.POST("/v1/responses/compact", s.ResponsesCompactHandler)
// OpenAI-compatible audio endpoint
r.POST("/v1/audio/transcriptions", middleware.TranscriptionMiddleware(), s.ChatHandler)