Idea on how to integrate mistral (vibe) and LMStudio (local gemma4) as agent runtimes.

[JBlohm]

I have asked Claude for a concept on how that could be done and I think the result is worth sharing.
Maybe lead developers of multica want to pick up on this.

Actually I think it is better to share the concept of the idea than opening a pull request against a fast evolving codebase.

So here we go:

Prompt used with Claude (Sonnet 4.6 High (thinking)

You are a software developer and we want to write an extenstion to the multica project on github. Momentarily so called runtimes (the tools like codex, gemini or claude) are automatically detect once multica is running. I want it to be also able to use vibe from antropic or ma local LMstudio with gemma4. So basically we need custom runtimes, which can be configured. Please look trough the multica code and investigate how this is currently handled and how we could potentially build that extension to the code.

This is the result:

Feature proposal: custom / configurable runtimes (Vibe + LMStudio)

Context: Right now the daemon auto-detects a fixed list of CLIs on PATH. This proposal adds two new providers — Anthropic's Vibe CLI and a local LMStudio server — and, more generally, establishes the pattern for adding any further custom runtime going forward.

---

How the current system works

After reading the codebase (around commit 4d110236), the runtime pipeline has five distinct layers:

LoadConfig()                 ← probes PATH for known CLIs
    ↓
agent.New(type, cfg)         ← factory dispatches to the right backend struct
    ↓
Backend.Execute(...)         ← spawns subprocess or makes HTTP call, returns Session
    ↓
execenv.InjectRuntimeConfig  ← writes CLAUDE.md / AGENTS.md into the task dir
execenv.context.go           ← maps provider → skills discovery path
    ↓
provider-logo.tsx            ← renders brand icon in the UI

Every existing provider (claude, codex, hermes, gemini, …) touches all five layers. A new provider must be wired into each one.

---

Two new providers

Vibe (Anthropic Vibe CLI)

Follows the existing CLI pattern exactly. Detection via exec.LookPath, output assumed to be the same Claude SDK NDJSON stream format (--output-format stream-json). If Vibe's wire format turns out to differ from Claude Code's, only the message-parsing block needs adjusting — the rest of the plumbing is identical.

LMStudio (local OpenAI-compatible HTTP server)

A genuinely new pattern: no subprocess, pure HTTP SSE client. LMStudio exposes an OpenAI-compatible REST API at http://localhost:1234/v1. Because the Backend interface only requires returning a *Session (two channels), the implementation sits cleanly inside the existing abstraction without changing any calling code. Activation is controlled by a single env var (MULTICA_LMSTUDIO_URL) rather than exec.LookPath.

---

Layer 1 — server/internal/daemon/config.go

Add two stanzas after the kiro block (~line 152):

// ── VIBE ──────────────────────────────────────────────────────────────────
vibePath := envOrDefault("MULTICA_VIBE_PATH", "vibe")
if _, err := exec.LookPath(vibePath); err == nil {
    agents["vibe"] = AgentEntry{
        Path:  vibePath,
        Model: strings.TrimSpace(os.Getenv("MULTICA_VIBE_MODEL")),
    }
}

// ── LMSTUDIO ──────────────────────────────────────────────────────────────
// No CLI to probe — activated by setting MULTICA_LMSTUDIO_URL.
// The Path field carries the base URL (e.g. "http://localhost:1234").
if lmURL := strings.TrimSpace(os.Getenv("MULTICA_LMSTUDIO_URL")); lmURL != "" {
    agents["lmstudio"] = AgentEntry{
        Path:  lmURL,
        Model: strings.TrimSpace(os.Getenv("MULTICA_LMSTUDIO_MODEL")),
    }
}

Update the len(agents) == 0 error message:

return Config{}, fmt.Errorf(
    "no agent found: install claude, codex, copilot, opencode, openclaw, hermes, " +
    "gemini, pi, cursor-agent, kimi, kiro-cli, or vibe (PATH), " +
    "or set MULTICA_LMSTUDIO_URL for a local LMStudio server")

Optionally parse MULTICA_VIBE_ARGS alongside the existing claudeArgs/codexArgs block:

vibeArgs, err := shellArgsFromEnv("MULTICA_VIBE_ARGS")
if err != nil {
    return Config{}, err
}

---

Layer 2 — server/pkg/agent/agent.go

Extend the New() switch (after the kiro case):

case "vibe":
    return &vibeBackend{cfg: cfg}, nil
case "lmstudio":
    return newLMStudioBackend(cfg), nil
default:
    return nil, fmt.Errorf(
        "unknown agent type: %q (supported: claude, codex, copilot, opencode, openclaw, "+
        "hermes, gemini, pi, cursor, kimi, kiro, vibe, lmstudio)", agentType)

Add to launchHeaders:

"vibe":     "vibe (stream-json)",
"lmstudio": "lmstudio (http sse)",

---

Layer 3a — server/pkg/agent/vibe.go (new file)

package agent

import (
    "bufio"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "os/exec"
    "strings"
    "time"
)

// vibeBackend spawns the Anthropic Vibe CLI and reads its NDJSON stream.
// It mirrors the claude backend closely; adjust parseVibeOutput if Vibe's
// wire format diverges from the Claude SDK stream-json protocol.
type vibeBackend struct {
    cfg Config
}

func (b *vibeBackend) Execute(ctx context.Context, prompt string, opts ExecOptions) (*Session, error) {
    execPath := b.cfg.ExecutablePath
    if execPath == "" {
        execPath = "vibe"
    }

    args := []string{
        "--output-format", "stream-json",
        "--print",
        "--no-interactive",
    }
    if opts.Model != "" {
        args = append(args, "--model", opts.Model)
    }
    if opts.SystemPrompt != "" {
        args = append(args, "--system-prompt", opts.SystemPrompt)
    }
    if opts.MaxTurns > 0 {
        args = append(args, "--max-turns", fmt.Sprintf("%d", opts.MaxTurns))
    }
    if opts.ResumeSessionID != "" {
        args = append(args, "--resume", opts.ResumeSessionID)
    }
    args = append(args, opts.ExtraArgs...)
    args = append(args, opts.CustomArgs...)
    args = append(args, prompt)

    cmd := exec.CommandContext(ctx, execPath, args...)
    cmd.Dir = opts.Cwd
    for k, v := range b.cfg.Env {
        cmd.Env = append(cmd.Env, k+"="+v)
    }

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return nil, fmt.Errorf("vibe stdout pipe: %w", err)
    }
    stderrPipe, err := cmd.StderrPipe()
    if err != nil {
        return nil, fmt.Errorf("vibe stderr pipe: %w", err)
    }
    if err := cmd.Start(); err != nil {
        return nil, fmt.Errorf("vibe start: %w", err)
    }

    msgCh := make(chan Message, 64)
    resultCh := make(chan Result, 1)

    go func() {
        defer close(msgCh)
        defer close(resultCh)
        b.stream(ctx, stdout, stderrPipe, cmd, opts, msgCh, resultCh)
    }()

    return &Session{Messages: msgCh, Result: resultCh}, nil
}

// vibeSDKMessage is the NDJSON envelope emitted by Vibe's stream-json mode.
// Field names match the Claude SDK protocol; update if Vibe's schema differs.
type vibeSDKMessage struct {
    Type    string          `json:"type"`
    Message json.RawMessage `json:"message"`
    Result  *struct {
        Subtype   string  `json:"subtype"`
        SessionID string  `json:"session_id"`
        TotalCost float64 `json:"total_cost_usd"`
        Usage     map[string]struct {
            InputTokens      int64 `json:"input_tokens"`
            OutputTokens     int64 `json:"output_tokens"`
            CacheReadTokens  int64 `json:"cache_read_input_tokens"`
            CacheWriteTokens int64 `json:"cache_creation_input_tokens"`
        } `json:"usage_by_model"`
    } `json:"result"`
}

func (b *vibeBackend) stream(
    ctx context.Context,
    stdout, stderr io.Reader,
    cmd *exec.Cmd,
    _ ExecOptions,
    msgCh chan<- Message,
    resultCh chan<- Result,
) {
    start := time.Now()
    stderrTail := newStderrTail(stderr)

    var textBuilder strings.Builder
    var sessionID string
    var usage map[string]TokenUsage

    scanner := bufio.NewScanner(stdout)
    scanner.Buffer(make([]byte, 1<<20), 1<<20)

    for scanner.Scan() {
        line := scanner.Bytes()
        if len(line) == 0 {
            continue
        }

        var msg vibeSDKMessage
        if err := json.Unmarshal(line, &msg); err != nil {
            b.cfg.Logger.Debug("vibe: unrecognised line", "raw", string(line))
            continue
        }

        switch msg.Type {
        case "assistant":
            var inner struct {
                Content []struct {
                    Type string `json:"type"`
                    Text string `json:"text"`
                } `json:"content"`
            }
            if err := json.Unmarshal(msg.Message, &inner); err == nil {
                for _, c := range inner.Content {
                    if c.Type == "text" && c.Text != "" {
                        textBuilder.WriteString(c.Text)
                        select {
                        case msgCh <- Message{Type: MessageText, Content: c.Text}:
                        case <-ctx.Done():
                            resultCh <- Result{
                                Status:     "cancelled",
                                Output:     textBuilder.String(),
                                SessionID:  sessionID,
                                DurationMs: time.Since(start).Milliseconds(),
                            }
                            _ = cmd.Wait()
                            return
                        }
                    }
                }
            }

        case "result":
            if msg.Result != nil {
                sessionID = msg.Result.SessionID
                usage = make(map[string]TokenUsage, len(msg.Result.Usage))
                for model, u := range msg.Result.Usage {
                    usage[model] = TokenUsage{
                        InputTokens:      u.InputTokens,
                        OutputTokens:     u.OutputTokens,
                        CacheReadTokens:  u.CacheReadTokens,
                        CacheWriteTokens: u.CacheWriteTokens,
                    }
                }
            }

        case "system", "user":
            // Informational; no forwarding needed.
        }
    }

    waitErr := cmd.Wait()
    errStr := stderrTail.String()

    if ctx.Err() != nil {
        resultCh <- Result{
            Status:     "cancelled",
            Output:     textBuilder.String(),
            SessionID:  sessionID,
            DurationMs: time.Since(start).Milliseconds(),
        }
        return
    }

    if waitErr != nil {
        msg := waitErr.Error()
        if errStr != "" {
            msg = errStr
        }
        resultCh <- Result{
            Status:     "failed",
            Output:     textBuilder.String(),
            Error:      msg,
            SessionID:  sessionID,
            DurationMs: time.Since(start).Milliseconds(),
        }
        return
    }

    resultCh <- Result{
        Status:     "completed",
        Output:     textBuilder.String(),
        SessionID:  sessionID,
        Usage:      usage,
        DurationMs: time.Since(start).Milliseconds(),
    }
}

---

Layer 3b — server/pkg/agent/lmstudio.go (new file)

package agent

import (
    "bufio"
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "strings"
    "time"
)

// lmstudioBackend calls a local LMStudio (or any OpenAI-compatible) server.
// cfg.ExecutablePath holds the base URL, e.g. "http://localhost:1234".
// Set MULTICA_LMSTUDIO_URL to activate; MULTICA_LMSTUDIO_MODEL to pick a model.
type lmstudioBackend struct {
    cfg    Config
    client *http.Client
}

func newLMStudioBackend(cfg Config) *lmstudioBackend {
    return &lmstudioBackend{
        cfg:    cfg,
        client: &http.Client{Timeout: 0}, // streaming — no deadline at the HTTP layer
    }
}

func (b *lmstudioBackend) Execute(ctx context.Context, prompt string, opts ExecOptions) (*Session, error) {
    baseURL := strings.TrimRight(b.cfg.ExecutablePath, "/")
    if baseURL == "" {
        baseURL = "http://localhost:1234"
    }

    model := opts.Model
    if model == "" {
        model = "local-model" // LMStudio uses whichever model is currently loaded
    }

    messages := make([]map[string]string, 0, 3)
    if opts.SystemPrompt != "" {
        messages = append(messages, map[string]string{"role": "system", "content": opts.SystemPrompt})
    }
    messages = append(messages, map[string]string{"role": "user", "content": prompt})

    body, err := json.Marshal(map[string]any{
        "model":    model,
        "messages": messages,
        "stream":   true,
    })
    if err != nil {
        return nil, fmt.Errorf("lmstudio: marshal request: %w", err)
    }

    req, err := http.NewRequestWithContext(ctx, http.MethodPost,
        baseURL+"/v1/chat/completions", bytes.NewReader(body))
    if err != nil {
        return nil, fmt.Errorf("lmstudio: build request: %w", err)
    }
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "text/event-stream")
    if key := b.cfg.Env["LMSTUDIO_API_KEY"]; key != "" {
        req.Header.Set("Authorization", "Bearer "+key)
    }

    resp, err := b.client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("lmstudio: HTTP request: %w", err)
    }
    if resp.StatusCode != http.StatusOK {
        _ = resp.Body.Close()
        return nil, fmt.Errorf("lmstudio: unexpected status %d", resp.StatusCode)
    }

    msgCh := make(chan Message, 64)
    resultCh := make(chan Result, 1)

    go func() {
        defer close(msgCh)
        defer close(resultCh)
        defer resp.Body.Close()
        b.stream(ctx, resp, model, msgCh, resultCh)
    }()

    return &Session{Messages: msgCh, Result: resultCh}, nil
}

type lmSSEChunk struct {
    Choices []struct {
        Delta struct {
            Content string `json:"content"`
        } `json:"delta"`
        FinishReason *string `json:"finish_reason"`
    } `json:"choices"`
    Usage *struct {
        PromptTokens     int64 `json:"prompt_tokens"`
        CompletionTokens int64 `json:"completion_tokens"`
    } `json:"usage"`
}

func (b *lmstudioBackend) stream(
    ctx context.Context,
    resp *http.Response,
    model string,
    msgCh chan<- Message,
    resultCh chan<- Result,
) {
    start := time.Now()
    var textBuilder strings.Builder
    var inputTokens, outputTokens int64

    scanner := bufio.NewScanner(resp.Body)
    scanner.Buffer(make([]byte, 1<<20), 1<<20)

    for scanner.Scan() {
        if ctx.Err() != nil {
            break
        }
        line := scanner.Text()
        if !strings.HasPrefix(line, "data: ") {
            continue
        }
        data := strings.TrimPrefix(line, "data: ")
        if data == "[DONE]" {
            break
        }

        var chunk lmSSEChunk
        if err := json.Unmarshal([]byte(data), &chunk); err != nil {
            b.cfg.Logger.Debug("lmstudio: unrecognised SSE line", "raw", data)
            continue
        }

        if chunk.Usage != nil {
            inputTokens = chunk.Usage.PromptTokens
            outputTokens = chunk.Usage.CompletionTokens
        }

        for _, choice := range chunk.Choices {
            content := choice.Delta.Content
            if content == "" {
                continue
            }
            textBuilder.WriteString(content)
            select {
            case msgCh <- Message{Type: MessageText, Content: content}:
            case <-ctx.Done():
                resultCh <- Result{
                    Status:     "cancelled",
                    Output:     textBuilder.String(),
                    DurationMs: time.Since(start).Milliseconds(),
                }
                return
            }
        }
    }

    if scanErr := scanner.Err(); scanErr != nil && ctx.Err() == nil {
        resultCh <- Result{
            Status:     "failed",
            Error:      fmt.Sprintf("lmstudio: read stream: %v", scanErr),
            Output:     textBuilder.String(),
            DurationMs: time.Since(start).Milliseconds(),
        }
        return
    }

    if ctx.Err() != nil {
        resultCh <- Result{
            Status:     "cancelled",
            Output:     textBuilder.String(),
            DurationMs: time.Since(start).Milliseconds(),
        }
        return
    }

    usage := map[string]TokenUsage{}
    if inputTokens > 0 || outputTokens > 0 {
        usage[model] = TokenUsage{
            InputTokens:  inputTokens,
            OutputTokens: outputTokens,
        }
    }

    resultCh <- Result{
        Status:     "completed",
        Output:     textBuilder.String(),
        Usage:      usage,
        DurationMs: time.Since(start).Milliseconds(),
    }
}

---

Layer 4 — server/internal/daemon/execenv/runtime_config.go

Inside the existing switch provider block:

case "vibe":
    // Vibe is Anthropic-native; reuse CLAUDE.md like Claude Code.
    return writeMD(dir, "CLAUDE.md", content)

case "lmstudio":
    // LMStudio reads no native instruction file; write a generic AGENTS.md
    // so the task context is present if the model is prompted to check it.
    return writeMD(dir, "AGENTS.md", content)

Layer 4 — server/internal/daemon/execenv/context.go

Inside the existing switch provider block for skills discovery:

case "vibe":
    // Mirror Claude's layout.
    skillsPath = filepath.Join(dir, ".claude", "skills")

case "lmstudio":
    skillsPath = filepath.Join(dir, ".multica", "skills")

---

Layer 5 — packages/views/runtimes/components/provider-logo.tsx

Add two entries to the existing providerType switch (placeholder icons until brand assets are available):

case "vibe":
    return <AnthropicIcon className={className} aria-label="Vibe" />;

case "lmstudio":
    return <ServerIcon className={className} aria-label="LMStudio" />;

---

New environment variables

Variable	Default	Purpose
MULTICA_VIBE_PATH	vibe	Custom path to the vibe binary
MULTICA_VIBE_MODEL	(empty)	Model override passed to the Vibe CLI
MULTICA_VIBE_ARGS	(empty)	Extra shell args prepended to every invocation
MULTICA_LMSTUDIO_URL	(none)	Base URL of the LMStudio server — setting this activates the runtime
MULTICA_LMSTUDIO_MODEL	local-model	Model name sent in the request body
MULTICA_LMSTUDIO_API_KEY	(empty)	Bearer token for OpenAI-compatible servers that require auth

---

Open questions for maintainers

1. Vibe wire format. The implementation above assumes Vibe emits the same Claude SDK NDJSON protocol (type: assistant | result | system | user). If Vibe uses a different envelope, only vibeSDKMessage and the switch msg.Type block in stream() need updating — everything else is unchanged.

2. LMStudio version detection. The existing daemon calls DetectVersion (runs <binary> --version) for all CLI agents. LMStudio has no binary to probe, so it skips this automatically. If surfacing the currently loaded model name in the Runtimes UI is desirable, a lightweight GET /v1/models call could be added inside LoadConfig to populate a version string.

3. Scope of "custom runtimes" more generally. The LMStudio pattern (env-var activation, HTTP backend) is a reusable template for any locally-hosted OpenAI-compatible server — Ollama, vLLM, llama.cpp with an HTTP frontend, etc. It may be worth establishing a first-class custom provider type that reads its base URL and model entirely from env vars, rather than shipping one named backend per local server variant.

---

Files changed summary

File	Change
server/internal/daemon/config.go	+~15 lines: two new detection stanzas, updated error message
server/pkg/agent/agent.go	+4 lines: two switch cases, two launchHeaders entries
server/pkg/agent/vibe.go	new file (~130 lines)
server/pkg/agent/lmstudio.go	new file (~140 lines)
server/internal/daemon/execenv/runtime_config.go	+~6 lines: two new switch cases
server/internal/daemon/execenv/context.go	+~4 lines: two new switch cases
packages/views/runtimes/components/provider-logo.tsx	+~4 lines: two new icon cases