Merge pull request #312 from dgageot/fix-281

Connect to DMR on the docker socket when possible

Author: dgageot

README.md

@@ -183,7 +183,7 @@ models:
 
 You'll find a curated list of agents examples, spread into 3 categories, [Basic](https://github.com/docker/cagent/tree/main/examples#basic-configurations), [Advanced](https://github.com/docker/cagent/tree/main/examples#advanced-configurations) and [multi-agents](https://github.com/docker/cagent/tree/main/examples#multi-agent-configurations) in the `/examples/` directory.
 
-### DMR provider options
+### DMR (Docker Model Runner) provider options
 
 When using the `dmr` provider, you can use the `provider_opts` key for DMR runtime-specific (e.g. llama.cpp) options:
 
@@ -197,7 +197,7 @@ models:
       runtime_flags: ["--ngl=33", "--repeat-penalty=1.2", ...] # or comma/space-separated string
 ```
 
-The default base_url `cagent` will use for dmr providers is `http://localhost:12434/engines/llama.cpp/v1`. DMR itself might need to be enabled via [Docker Desktop's settings](https://docs.docker.com/ai/model-runner/get-started/#enable-dmr-in-docker-desktop) on MacOS and Windows, and via command line on [Docker CE on Linux](https://docs.docker.com/ai/model-runner/get-started/#enable-dmr-in-docker-engine).
+The default base_url `cagent` will use for DMR providers is `http://localhost:12434/engines/llama.cpp/v1`. DMR itself might need to be enabled via [Docker Desktop's settings](https://docs.docker.com/ai/model-runner/get-started/#enable-dmr-in-docker-desktop) on MacOS and Windows, and via command line on [Docker CE on Linux](https://docs.docker.com/ai/model-runner/get-started/#enable-dmr-in-docker-engine).
 
 ## Quickly generate agents and agent teams with `cagent new`
 

examples/pirate.yaml

@@ -8,3 +8,4 @@ agents:
     model: openai/gpt-4o
     # model: anthropic/claude-3-5-sonnet-latest
     # model: gemini/gemini-2.5-flash
+    # model: dmr/ai/llama3.2

pkg/model/provider/dmr/client.go

@@ -7,6 +7,8 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"net"
+	"net/http"
 	"os"
 	"os/exec"
 	"strconv"
@@ -29,7 +31,7 @@ type Client struct {
 }
 
 // NewClient creates a new DMR client from the provided configuration
-func NewClient(_ context.Context, cfg *latest.ModelConfig, opts ...options.Opt) (*Client, error) {
+func NewClient(ctx context.Context, cfg *latest.ModelConfig, opts ...options.Opt) (*Client, error) {
 	if cfg == nil {
 		slog.Error("DMR client creation failed", "error", "model configuration is required")
 		return nil, errors.New("model configuration is required")
@@ -45,49 +47,63 @@ func NewClient(_ context.Context, cfg *latest.ModelConfig, opts ...options.Opt)
 		opt(&globalOptions)
 	}
 
-	// Resolve base_url for DMR models. If not provided, configure with the docker model plugin, else fallback.
-	baseURL := cfg.BaseURL
-	if baseURL == "" {
-		endpoint, engine, err := getDockerModelEndpointAndEngine()
-		if err != nil {
-			slog.Debug("docker model status query failed", "error", err)
-		}
+	endpoint, engine, err := getDockerModelEndpointAndEngine(ctx)
+	if err != nil {
+		slog.Debug("docker model status query failed", "error", err)
+	}
 
-		// Build runtime flags from ModelConfig and engine
-		contextSize, providerRuntimeFlags := parseDMRProviderOpts(cfg)
-		configFlags := buildRuntimeFlagsFromModelConfig(engine, cfg)
-		finalFlags, warnings := mergeRuntimeFlagsPreferUser(configFlags, providerRuntimeFlags)
-		for _, w := range warnings {
-			slog.Warn(w)
-		}
-		slog.Debug("DMR provider_opts parsed", "model", cfg.Model, "context_size", contextSize, "runtime_flags", finalFlags, "engine", engine)
-		if err := configureDockerModel(cfg.Model, contextSize, finalFlags); err != nil {
-			slog.Debug("docker model configure skipped or failed", "error", err)
-		}
+	clientConfig := openai.DefaultConfig("")
 
-		if endpoint != "" {
-			baseURL = endpoint
-			slog.Debug("Using docker model endpoint for DMR base_url", "base_url", baseURL)
-		} else {
-			baseURL = "http://localhost:12434/engines/llama.cpp/v1"
-			slog.Debug("Using default DMR base_url", "base_url", baseURL)
+	switch {
+	case cfg.BaseURL != "":
+		clientConfig.BaseURL = cfg.BaseURL
+	case os.Getenv("MODEL_RUNNER_HOST") != "":
+		clientConfig.BaseURL = os.Getenv("MODEL_RUNNER_HOST")
+	case inContainer():
+		// This won't work with Docker CE but we have no way to detect that from inside the container.
+		clientConfig.BaseURL = "http://model-runner.docker.internal/engines/v1/"
+	case endpoint == "http://model-runner.docker.internal/engines/v1/":
+		// Docker Desktop
+		clientConfig.BaseURL = "http://_/exp/vDD4.40/engines/v1"
+		clientConfig.HTTPClient = &http.Client{
+			Transport: &http.Transport{
+				DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+					var d net.Dialer
+					return d.DialContext(ctx, "unix", "/var/run/docker.sock")
+				},
+			},
 		}
+	default:
+		// Docker CE
+		clientConfig.BaseURL = endpoint
 	}
 
-	slog.Debug("Creating DMR client config", "base_url", baseURL)
-	clientConfig := openai.DefaultConfig("")
-	clientConfig.BaseURL = baseURL
+	// Build runtime flags from ModelConfig and engine
+	contextSize, providerRuntimeFlags := parseDMRProviderOpts(cfg)
+	configFlags := buildRuntimeFlagsFromModelConfig(engine, cfg)
+	finalFlags, warnings := mergeRuntimeFlagsPreferUser(configFlags, providerRuntimeFlags)
+	for _, w := range warnings {
+		slog.Warn(w)
+	}
+	slog.Debug("DMR provider_opts parsed", "model", cfg.Model, "context_size", contextSize, "runtime_flags", finalFlags, "engine", engine)
+	if err := configureDockerModel(ctx, cfg.Model, contextSize, finalFlags); err != nil {
+		slog.Debug("docker model configure skipped or failed", "error", err)
+	}
 
-	client := openai.NewClientWithConfig(clientConfig)
-	slog.Debug("DMR client created successfully", "model", cfg.Model, "base_url", baseURL)
+	slog.Debug("DMR client created successfully", "model", cfg.Model, "base_url", clientConfig.BaseURL)
 
 	return &Client{
-		client:  client,
+		client:  openai.NewClientWithConfig(clientConfig),
 		config:  cfg,
-		baseURL: baseURL,
+		baseURL: clientConfig.BaseURL,
 	}, nil
 }
 
+func inContainer() bool {
+	finfo, err := os.Stat("/.dockerenv")
+	return err == nil && finfo.Mode().IsRegular()
+}
+
 func convertMultiContent(multiContent []chat.MessagePart) []openai.ChatMessagePart {
 	openaiMultiContent := make([]openai.ChatMessagePart, len(multiContent))
 	for i, part := range multiContent {
@@ -290,7 +306,8 @@ func (c *Client) CreateChatCompletionStream(
 		"model", c.config.Model,
 		"message_count", len(messages),
 		"tool_count", len(requestTools),
-		"base_url", c.baseURL)
+		"base_url", c.baseURL,
+	)
 
 	if len(messages) == 0 {
 		slog.Error("DMR stream creation failed", "error", "at least one message is required")
@@ -366,7 +383,7 @@ func (c *Client) CreateChatCompletionStream(
 		return nil, err
 	}
 
-	slog.Debug("DMR chat completion stream created successfully", "model", c.config.Model)
+	slog.Debug("DMR chat completion stream created successfully", "model", c.config.Model, "base_url", c.baseURL)
 	return newStreamAdapter(stream, trackUsage), nil
 }
 
@@ -383,7 +400,7 @@ func (c *Client) CreateChatCompletion(
 
 	response, err := c.client.CreateChatCompletion(ctx, request)
 	if err != nil {
-		slog.Error("DMR chat completion failed", "error", err, "model", c.config.Model, "base_url", c.baseURL)
+		slog.Error("DMR chat completion failed", "error", err, "model", c.config.Model)
 		return "", err
 	}
 
@@ -464,10 +481,10 @@ func parseDMRProviderOpts(cfg *latest.ModelConfig) (contextSize int, runtimeFlag
 	return contextSize, runtimeFlags
 }
 
-func configureDockerModel(model string, contextSize int, runtimeFlags []string) error {
+func configureDockerModel(ctx context.Context, model string, contextSize int, runtimeFlags []string) error {
 	args := buildDockerModelConfigureArgs(model, contextSize, runtimeFlags)
 
-	cmd := exec.Command("docker", args...)
+	cmd := exec.CommandContext(ctx, "docker", args...)
 	slog.Debug("Running docker model configure", "model", model, "args", args)
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -494,14 +511,15 @@ func buildDockerModelConfigureArgs(model string, contextSize int, runtimeFlags [
 	return args
 }
 
-func getDockerModelEndpointAndEngine() (endpoint, engine string, err error) {
-	cmd := exec.Command("docker", "model", "status", "--json")
+func getDockerModelEndpointAndEngine(ctx context.Context) (endpoint, engine string, err error) {
+	cmd := exec.CommandContext(ctx, "docker", "model", "status", "--json")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	if err := cmd.Run(); err != nil {
 		return "", "", errors.New(strings.TrimSpace(stderr.String()))
 	}
+
 	type status struct {
 		Running  bool              `json:"running"`
 		Backends map[string]string `json:"backends"`
@@ -512,16 +530,8 @@ func getDockerModelEndpointAndEngine() (endpoint, engine string, err error) {
 	if err := json.Unmarshal(stdout.Bytes(), &st); err != nil {
 		return "", "", err
 	}
-	endpoint = strings.TrimSpace(st.Endpoint)
-
-	inDockerContainer := false
-	finfo, err := os.Stat("/.dockerenv")
-	if err == nil && finfo.Mode().IsRegular() {
-		inDockerContainer = true
-	}
 
-	// normalize endpoint considering container environment
-	endpoint = normalizeDMREndpoint(endpoint, inDockerContainer)
+	endpoint = strings.TrimSpace(st.Endpoint)
 
 	engine = strings.TrimSpace(st.Engine)
 	if engine == "" {
@@ -539,23 +549,8 @@ func getDockerModelEndpointAndEngine() (endpoint, engine string, err error) {
 	if engine == "" {
 		engine = "llama.cpp"
 	}
-	return endpoint, engine, nil
-}
 
-// normalizeDMREndpoint applies an override to the endpoint reported by
-// `docker model status --json` to ensure the DMR client uses a reachable address
-// from the current environment.
-func normalizeDMREndpoint(endpoint string, inDockerContainer bool) string {
-	// This env overriding might need to be updated if we end up having multiple separate DMR
-	// engines with different endpoints running at the same time
-	if hostEnvVar := os.Getenv("MODEL_RUNNER_HOST"); hostEnvVar != "" {
-		return hostEnvVar
-	}
-	// Only override if not running in a docker container
-	if endpoint == "http://model-runner.docker.internal/engines/v1/" && !inDockerContainer {
-		return "http://localhost:12434/engines/llama.cpp/v1"
-	}
-	return endpoint
+	return endpoint, engine, nil
 }
 
 // buildRuntimeFlagsFromModelConfig converts standard ModelConfig fields into backend-specific

pkg/model/provider/dmr/client_test.go

@@ -1,61 +1,34 @@
 package dmr
 
 import (
-	"context"
 	"reflect"
 	"testing"
 
 	latest "github.com/docker/cagent/pkg/config/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func TestNewClientWithDefaultBaseURL(t *testing.T) {
-	// No base_url provided, should use default
-	cfg := &latest.ModelConfig{
-		Provider: "dmr",
-		Model:    "ai/qwen3",
-		// BaseURL is empty, should use default
-	}
-
-	client, err := NewClient(context.Background(), cfg)
-	if err != nil {
-		t.Fatalf("Expected no error, got %v", err)
-	}
-
-	if client.baseURL != "http://localhost:12434/engines/llama.cpp/v1" {
-		t.Errorf("Expected default baseURL to be 'http://localhost:12434/engines/llama.cpp/v1', got '%s'", client.baseURL)
-	}
-}
-
 func TestNewClientWithExplicitBaseURL(t *testing.T) {
-	// Explicit base_url provided, should use that
-	customURL := "https://custom.example.com:8080/api/v1"
 	cfg := &latest.ModelConfig{
 		Provider: "dmr",
 		Model:    "ai/qwen3",
-		BaseURL:  customURL,
-	}
-
-	client, err := NewClient(context.Background(), cfg)
-	if err != nil {
-		t.Fatalf("Expected no error, got %v", err)
+		BaseURL:  "https://custom.example.com:8080/api/v1",
 	}
 
-	if client.baseURL != customURL {
-		t.Errorf("Expected baseURL to be '%s', got '%s'", customURL, client.baseURL)
-	}
+	client, err := NewClient(t.Context(), cfg)
+	require.NoError(t, err)
+	assert.Equal(t, "https://custom.example.com:8080/api/v1", client.baseURL)
 }
 
 func TestNewClientWithWrongType(t *testing.T) {
-	// Wrong model type, should return error
 	cfg := &latest.ModelConfig{
-		Provider: "openai", // Wrong type
+		Provider: "openai",
 		Model:    "gpt-4",
 	}
 
-	_, err := NewClient(context.Background(), cfg)
-	if err == nil {
-		t.Fatal("Expected error for wrong model type, got nil")
-	}
+	_, err := NewClient(t.Context(), cfg)
+	require.Error(t, err)
 }
 
 func TestBuildDockerConfigureArgs(t *testing.T) {
@@ -121,85 +94,3 @@ func TestMergeRuntimeFlagsPreferUser_WarnsAndPrefersUser(t *testing.T) {
 		t.Fatalf("unexpected merged flags.\nexpected: %#v\nactual:   %#v", expected, merged)
 	}
 }
-
-func TestNormalizeDMREndpoint_NoEnvOverride(t *testing.T) {
-	tests := []struct {
-		name              string
-		endpoint          string
-		inDockerContainer bool
-		want              string
-	}{
-		{
-			name:              "override when not in docker",
-			endpoint:          "http://model-runner.docker.internal/engines/v1/",
-			inDockerContainer: false,
-			want:              "http://localhost:12434/engines/llama.cpp/v1",
-		},
-		{
-			name:              "no override when in docker",
-			endpoint:          "http://model-runner.docker.internal/engines/v1/",
-			inDockerContainer: true,
-			want:              "http://model-runner.docker.internal/engines/v1/",
-		},
-		{
-			name:              "other endpoint unchanged",
-			endpoint:          "http://example/engines/v1/",
-			inDockerContainer: false,
-			want:              "http://example/engines/v1/",
-		},
-		{
-			name:              "empty endpoint unchanged",
-			endpoint:          "",
-			inDockerContainer: false,
-			want:              "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := normalizeDMREndpoint(tt.endpoint, tt.inDockerContainer)
-			if got != tt.want {
-				t.Fatalf("normalizeDMREndpoint(%q, %v) = %q, want %q", tt.endpoint, tt.inDockerContainer, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestNormalizeDMREndpoint_EnvOverride(t *testing.T) {
-	t.Setenv("MODEL_RUNNER_HOST", "http://myhost:9999/custom/v1")
-
-	tests := []struct {
-		name              string
-		endpoint          string
-		inDockerContainer bool
-		want              string
-	}{
-		{
-			name:              "env overrides non-container default endpoint",
-			endpoint:          "http://model-runner.docker.internal/engines/v1/",
-			inDockerContainer: false,
-			want:              "http://myhost:9999/custom/v1",
-		},
-		{
-			name:              "env overrides in-container default endpoint",
-			endpoint:          "http://model-runner.docker.internal/engines/v1/",
-			inDockerContainer: true,
-			want:              "http://myhost:9999/custom/v1",
-		},
-		{
-			name:              "env overrides arbitrary endpoint",
-			endpoint:          "http://example/engines/v1/",
-			inDockerContainer: false,
-			want:              "http://myhost:9999/custom/v1",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := normalizeDMREndpoint(tt.endpoint, tt.inDockerContainer)
-			if got != tt.want {
-				t.Fatalf("normalizeDMREndpoint should prefer env var: got %q, want %q", got, tt.want)
-			}
-		})
-	}
-}