Leonid PershinandCursor
714da5c38b
Treat ViewSpecial/Models/*.preview URLs as non-gens, scrub them from the board, and never attach them to chat/look_at/snapshot. Co-authored-by: Cursor <cursoragent@cursor.com>
1997 lines
76 KiB
C#
1997 lines
76 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Net.Http.Headers;
|
|
using System.Net.WebSockets;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using FreneticUtilities.FreneticExtensions;
|
|
using Newtonsoft.Json.Linq;
|
|
using SwarmUI.Accounts;
|
|
using SwarmUI.Core;
|
|
using SwarmUI.Text2Image;
|
|
using SwarmUI.Utils;
|
|
using SwarmUI.WebAPI;
|
|
|
|
namespace Mrleo1nid.SwarmAssistent;
|
|
|
|
/// <summary>Krea 2 collaborative assistant: Ollama chat + vision + prompt/LoRA/params patches + Generate/Civitai.</summary>
|
|
public class SwarmAssistentExtension : Extension
|
|
{
|
|
public static PermInfo PermUse = Permissions.Register(new(
|
|
"swarm_assistent_use",
|
|
"[Swarm Assistent] Use",
|
|
"Allows using the Swarm Assistent chat (Ollama proxy).",
|
|
PermissionDefault.USER,
|
|
Permissions.GroupUser));
|
|
|
|
public static HttpClient HttpClient;
|
|
|
|
public AssistentConfig Config;
|
|
public AssistentMemory Memory;
|
|
|
|
const int MaxCivitaiHopsFallback = 2;
|
|
const int MaxLorasInInventoryFallback = 150;
|
|
const int MaxWildcardsInInventoryFallback = 80;
|
|
const int MaxCheckpointsInInventoryFallback = 60;
|
|
const int InventoryBlurbMaxFallback = 140;
|
|
const int DefaultNumCtxFallback = 16384;
|
|
|
|
static readonly Regex JsonFenceRe = new(@"```(?:json)?\s*([\s\S]*?)```", RegexOptions.IgnoreCase | RegexOptions.Compiled);
|
|
|
|
public override void OnPreInit()
|
|
{
|
|
ScriptFiles.Add("Assets/assistent.js");
|
|
StyleSheetFiles.Add("Assets/assistent.css");
|
|
ExtensionAuthor = "mrleo1nid";
|
|
Description = "Collaborative Krea 2 assistant: Ollama chat, persona presets, vector memory, model cards, Generate loop.";
|
|
License = "MIT";
|
|
Version = "0.7.1";
|
|
Tags = ["tabs", "ui", "llm", "ollama", "krea", "inpaint", "memory"];
|
|
}
|
|
|
|
public override void OnInit()
|
|
{
|
|
HttpClient ??= new HttpClient { Timeout = TimeSpan.FromMinutes(10) };
|
|
Config = new AssistentConfig(FilePath, DataRoot());
|
|
Memory = new AssistentMemory(DataRoot(), HttpClient, Config.LoadAssistant(Config.DefaultPersonaId())["embed_model"]?.ToString() ?? "nomic-embed-text");
|
|
API.RegisterAPICall(AssistentListModels, false, PermUse);
|
|
API.RegisterAPICall(AssistentGetPacks, false, PermUse);
|
|
API.RegisterAPICall(AssistentListPersonas, false, PermUse);
|
|
API.RegisterAPICall(AssistentGetConfig, false, PermUse);
|
|
API.RegisterAPICall(AssistentGetSettings, false, PermUse);
|
|
API.RegisterAPICall(AssistentSaveSettings, true, PermUse);
|
|
API.RegisterAPICall(AssistentListInventory, false, PermUse);
|
|
API.RegisterAPICall(AssistentGetCard, false, PermUse);
|
|
API.RegisterAPICall(AssistentSaveCard, true, PermUse);
|
|
API.RegisterAPICall(AssistentEnqueueWanted, true, PermUse);
|
|
API.RegisterAPICall(AssistentGetCardMeta, false, PermUse);
|
|
API.RegisterAPICall(AssistentSearchCivitai, false, PermUse);
|
|
API.RegisterAPICall(AssistentGetTaste, false, PermUse);
|
|
API.RegisterAPICall(AssistentSaveTaste, true, PermUse);
|
|
API.RegisterAPICall(AssistentChat, true, PermUse);
|
|
API.RegisterAPICall(AssistentChatWS, true, PermUse);
|
|
Logs.Init("Swarm Assistent extension loaded (Config presets + vector memory)");
|
|
}
|
|
|
|
int CfgInt(string key, int fallback)
|
|
{
|
|
try
|
|
{
|
|
return Config?.LoadAssistant(Config.DefaultPersonaId())[key]?.Value<int?>() ?? fallback;
|
|
}
|
|
catch
|
|
{
|
|
return fallback;
|
|
}
|
|
}
|
|
|
|
static string Clip(string text, int max)
|
|
{
|
|
if (string.IsNullOrEmpty(text) || text.Length <= max)
|
|
{
|
|
return text ?? "";
|
|
}
|
|
return text[..max] + "…";
|
|
}
|
|
|
|
public static string NormalizeBaseUrl(string raw)
|
|
{
|
|
string url = (raw ?? "").Trim();
|
|
if (string.IsNullOrWhiteSpace(url))
|
|
{
|
|
url = "http://127.0.0.1:11434";
|
|
}
|
|
return url.TrimEnd('/');
|
|
}
|
|
|
|
public string ReadPackFile(string name)
|
|
{
|
|
return Config?.LoadPackPrompt(Config.DefaultPersonaId(), name);
|
|
}
|
|
|
|
public async Task<JObject> AssistentListModels(Session session, string baseUrl)
|
|
{
|
|
string root = NormalizeBaseUrl(baseUrl);
|
|
try
|
|
{
|
|
using HttpResponseMessage resp = await HttpClient.GetAsync($"{root}/api/tags");
|
|
string body = await resp.Content.ReadAsStringAsync();
|
|
if (!resp.IsSuccessStatusCode)
|
|
{
|
|
return new JObject { ["error"] = $"Ollama /api/tags HTTP {(int)resp.StatusCode}: {Clip(body, 400)}" };
|
|
}
|
|
JObject parsed = JObject.Parse(body);
|
|
JArray all = [];
|
|
foreach (JToken m in parsed["models"] as JArray ?? [])
|
|
{
|
|
string name = m["name"]?.ToString() ?? m["model"]?.ToString() ?? "";
|
|
if (!string.IsNullOrWhiteSpace(name))
|
|
{
|
|
all.Add(name);
|
|
}
|
|
}
|
|
JObject roles = Config?.LoadOllamaRoles() ?? new JObject();
|
|
HashSet<string> chatSet = new(
|
|
(roles["chat"] as JArray)?.Select(t => t?.ToString()).Where(s => !string.IsNullOrWhiteSpace(s)) ?? [],
|
|
StringComparer.OrdinalIgnoreCase);
|
|
HashSet<string> memSet = new(
|
|
(roles["memory"] as JArray)?.Select(t => t?.ToString()).Where(s => !string.IsNullOrWhiteSpace(s)) ?? [],
|
|
StringComparer.OrdinalIgnoreCase);
|
|
// Heuristic fallbacks when sidecar missing
|
|
if (chatSet.Count == 0 && memSet.Count == 0)
|
|
{
|
|
foreach (JToken t in all)
|
|
{
|
|
string n = t.ToString();
|
|
if (LooksLikeEmbedModel(n))
|
|
{
|
|
memSet.Add(n);
|
|
}
|
|
else
|
|
{
|
|
chatSet.Add(n);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Keep only tags that exist; anything unlabeled goes to chat if not memory
|
|
foreach (JToken t in all)
|
|
{
|
|
string n = t.ToString();
|
|
if (memSet.Contains(n) || LooksLikeEmbedModel(n))
|
|
{
|
|
memSet.Add(n);
|
|
chatSet.Remove(n);
|
|
}
|
|
else if (chatSet.Count == 0 || chatSet.Contains(n))
|
|
{
|
|
chatSet.Add(n);
|
|
}
|
|
else if (!memSet.Contains(n))
|
|
{
|
|
chatSet.Add(n);
|
|
}
|
|
}
|
|
}
|
|
JArray models = new(all.Select(t => t.ToString()).Where(n => chatSet.Contains(n) && !memSet.Contains(n) && !LooksLikeEmbedModel(n)));
|
|
JArray memoryModels = new(all.Select(t => t.ToString()).Where(n => memSet.Contains(n) || LooksLikeEmbedModel(n)).Distinct(StringComparer.OrdinalIgnoreCase).ToList());
|
|
if (memoryModels.Count == 0)
|
|
{
|
|
string fallback = Config?.LoadAssistant(Config.DefaultPersonaId())["embed_model"]?.ToString() ?? "nomic-embed-text";
|
|
if (all.Any(t => string.Equals(t.ToString(), fallback, StringComparison.OrdinalIgnoreCase)
|
|
|| t.ToString().StartsWith(fallback.Split(':')[0], StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
memoryModels.Add(all.Select(t => t.ToString()).First(n =>
|
|
string.Equals(n, fallback, StringComparison.OrdinalIgnoreCase)
|
|
|| n.StartsWith(fallback.Split(':')[0], StringComparison.OrdinalIgnoreCase)));
|
|
}
|
|
}
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["base_url"] = root,
|
|
["models"] = models,
|
|
["memory_models"] = memoryModels,
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new JObject { ["error"] = $"Ollama unreachable at {root}: {ex.Message}" };
|
|
}
|
|
}
|
|
|
|
static bool LooksLikeEmbedModel(string name)
|
|
{
|
|
string n = (name ?? "").ToLowerInvariant();
|
|
return n.Contains("embed") || n.Contains("nomic") || n.Contains("bge-") || n.Contains("minilm") || n.Contains("e5-");
|
|
}
|
|
|
|
public async Task<JObject> AssistentGetPacks(Session session, string persona = null)
|
|
{
|
|
await Task.CompletedTask;
|
|
string pid = AssistentConfig.SafeId(persona) ?? Config.DefaultPersonaId();
|
|
JObject packs = new();
|
|
JArray order = [];
|
|
foreach (var p in Config.ListPacks(pid))
|
|
{
|
|
string text = Config.LoadPackPrompt(pid, p.id);
|
|
if (text is not null)
|
|
{
|
|
packs[p.id] = text;
|
|
}
|
|
order.Add(p.id);
|
|
}
|
|
return new JObject { ["success"] = true, ["packs"] = packs, ["order"] = order, ["persona"] = pid };
|
|
}
|
|
|
|
public async Task<JObject> AssistentGetConfig(Session session, string persona = null)
|
|
{
|
|
await Task.CompletedTask;
|
|
string pid = AssistentConfig.SafeId(persona) ?? Config.DefaultPersonaId();
|
|
return Config.BuildMergedConfigPayload(pid);
|
|
}
|
|
|
|
public async Task<JObject> AssistentGetSettings(Session session)
|
|
{
|
|
await Task.CompletedTask;
|
|
return new JObject { ["success"] = true, ["settings"] = Config.LoadSettings() };
|
|
}
|
|
|
|
public async Task<JObject> AssistentSaveSettings(Session session, JObject settings)
|
|
{
|
|
await Task.CompletedTask;
|
|
if (settings is null)
|
|
{
|
|
return new JObject { ["error"] = "settings required" };
|
|
}
|
|
string prevEmbed = Config.LoadSettings()["embed_model"]?.ToString();
|
|
Config.SaveSettings(settings);
|
|
string nextEmbed = settings["embed_model"]?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(nextEmbed) && !string.Equals(prevEmbed, nextEmbed, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
try
|
|
{
|
|
await Memory.ReembedAllAsync(NormalizeBaseUrl(settings["base_url"]?.ToString()), nextEmbed);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"AssistentSaveSettings reembed: {ex.Message}");
|
|
}
|
|
}
|
|
return new JObject { ["success"] = true, ["path"] = Path.Combine(Config.OverlayRoot, "settings.json") };
|
|
}
|
|
|
|
static string DataRoot()
|
|
{
|
|
if (Directory.Exists("/mnt/swarm_data"))
|
|
{
|
|
return "/mnt/swarm_data";
|
|
}
|
|
try
|
|
{
|
|
string models = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "Models"));
|
|
if (Directory.Exists(models))
|
|
{
|
|
return Path.GetDirectoryName(models) ?? Environment.CurrentDirectory;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
return Environment.CurrentDirectory;
|
|
}
|
|
|
|
string PersonasOverlayJsonPath() => Path.Combine(DataRoot(), "Assistent", "personas.json");
|
|
|
|
string WantedModelsPath() => Path.Combine(DataRoot(), ".gpu-rent-wanted-models.yaml");
|
|
|
|
string WantedCardsDir() => Path.Combine(DataRoot(), ".gpu-rent-wanted-cards");
|
|
|
|
public async Task<JObject> AssistentListPersonas(Session session)
|
|
{
|
|
await Task.CompletedTask;
|
|
var catalog = Config.ListPersonaCatalog();
|
|
JArray list = [];
|
|
foreach (var p in catalog)
|
|
{
|
|
list.Add(new JObject
|
|
{
|
|
["id"] = p.id,
|
|
["title"] = p.title,
|
|
["accent"] = p.accent,
|
|
["prompt"] = Config.RenderIdentityBlock(p.id),
|
|
["source"] = p.source,
|
|
});
|
|
}
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["default"] = Config.DefaultPersonaId(),
|
|
["personas"] = list,
|
|
};
|
|
}
|
|
|
|
static string ModelWeightPath(string setName, string modelName)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(modelName) || !Program.T2IModelSets.TryGetValue(setName, out T2IModelHandler handler))
|
|
{
|
|
return null;
|
|
}
|
|
if (!handler.Models.TryGetValue(modelName, out T2IModel model) && !handler.Models.TryGetValue(modelName.Replace('\\', '/'), out model))
|
|
{
|
|
// Try suffix match
|
|
model = handler.Models.Values.FirstOrDefault(m =>
|
|
string.Equals(m.Name, modelName, StringComparison.OrdinalIgnoreCase)
|
|
|| m.Name.EndsWith("/" + modelName, StringComparison.OrdinalIgnoreCase)
|
|
|| Path.GetFileNameWithoutExtension(m.Name) == Path.GetFileNameWithoutExtension(modelName));
|
|
}
|
|
if (model is null)
|
|
{
|
|
return null;
|
|
}
|
|
try
|
|
{
|
|
// SwarmUI T2IModel exposes RawFilePath in recent builds.
|
|
return model.RawFilePath;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static string CardPathForWeight(string weightPath)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(weightPath))
|
|
{
|
|
return null;
|
|
}
|
|
string dir = Path.GetDirectoryName(weightPath);
|
|
string stem = Path.GetFileNameWithoutExtension(weightPath);
|
|
if (string.IsNullOrWhiteSpace(dir) || string.IsNullOrWhiteSpace(stem))
|
|
{
|
|
return null;
|
|
}
|
|
return Path.Combine(dir, $"{stem}.assistent.json");
|
|
}
|
|
|
|
static string SetNameForKind(string kind)
|
|
{
|
|
return (kind ?? "").Trim().ToLowerInvariant() switch
|
|
{
|
|
"lora" => "LoRA",
|
|
"checkpoint" or "ckpt" or "stable-diffusion" => "Stable-Diffusion",
|
|
_ => null,
|
|
};
|
|
}
|
|
|
|
JObject ReadCardObject(string kind, string name)
|
|
{
|
|
string set = SetNameForKind(kind);
|
|
string weight = ModelWeightPath(set, name);
|
|
string card = CardPathForWeight(weight);
|
|
if (card is null || !File.Exists(card))
|
|
{
|
|
return null;
|
|
}
|
|
try
|
|
{
|
|
return JObject.Parse(File.ReadAllText(card, Encoding.UTF8));
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public async Task<JObject> AssistentGetCard(Session session, string kind, string name)
|
|
{
|
|
await Task.CompletedTask;
|
|
if (string.IsNullOrWhiteSpace(kind) || string.IsNullOrWhiteSpace(name))
|
|
{
|
|
return new JObject { ["error"] = "kind and name required" };
|
|
}
|
|
JObject card = ReadCardObject(kind, name);
|
|
string set = SetNameForKind(kind);
|
|
string weight = ModelWeightPath(set, name);
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["kind"] = kind,
|
|
["name"] = name,
|
|
["has_card"] = card is not null,
|
|
["weight_path"] = weight,
|
|
["card"] = card,
|
|
};
|
|
}
|
|
|
|
public async Task<JObject> AssistentSaveCard(Session session, string kind, string name, JObject card, bool enqueue_wanted = false)
|
|
{
|
|
await Task.CompletedTask;
|
|
if (card is null)
|
|
{
|
|
return new JObject { ["error"] = "card required" };
|
|
}
|
|
kind = (kind ?? card["kind"]?.ToString() ?? "").Trim();
|
|
name = (name ?? card["name"]?.ToString() ?? "").Trim();
|
|
if (string.IsNullOrWhiteSpace(kind) || string.IsNullOrWhiteSpace(name))
|
|
{
|
|
return new JObject { ["error"] = "kind and name required" };
|
|
}
|
|
card["kind"] = kind;
|
|
card["name"] = name;
|
|
|
|
string set = SetNameForKind(kind);
|
|
string weight = ModelWeightPath(set, name);
|
|
if (!string.IsNullOrWhiteSpace(weight) && File.Exists(weight))
|
|
{
|
|
string path = CardPathForWeight(weight);
|
|
File.WriteAllText(path, card.ToString(Newtonsoft.Json.Formatting.Indented), Encoding.UTF8);
|
|
_ = IngestCardToMemory(card, name);
|
|
return new JObject { ["success"] = true, ["path"] = path, ["installed"] = true };
|
|
}
|
|
|
|
// Not installed — draft into wanted-cards + optionally enqueue download for next up.
|
|
Directory.CreateDirectory(WantedCardsDir());
|
|
string rawVid = card["version_id"]?.ToString() ?? "draft";
|
|
string vid = Regex.IsMatch(rawVid, @"^\d+$") ? rawVid : "draft";
|
|
string draft = Path.Combine(WantedCardsDir(), $"{vid}.assistent.json");
|
|
File.WriteAllText(draft, card.ToString(Newtonsoft.Json.Formatting.Indented), Encoding.UTF8);
|
|
if (enqueue_wanted || !string.IsNullOrWhiteSpace(card["civitai_url"]?.ToString()))
|
|
{
|
|
await AssistentEnqueueWanted(session, kind, card["civitai_url"]?.ToString(), card["version_id"]?.Value<int?>() ?? 0, card["title"]?.ToString() ?? name, card);
|
|
}
|
|
_ = IngestCardToMemory(card, name);
|
|
return new JObject { ["success"] = true, ["path"] = draft, ["installed"] = false, ["wanted"] = true };
|
|
}
|
|
|
|
async Task IngestCardToMemory(JObject card, string name)
|
|
{
|
|
if (Memory is null || card is null)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
string kind = (card["kind"]?.ToString() ?? "lora").Trim().ToLowerInvariant();
|
|
string key = (card["name"]?.ToString() ?? name ?? "").Trim();
|
|
List<string> bits = [];
|
|
foreach (string field in new[] { "when", "avoid", "prompt_hint", "notes" })
|
|
{
|
|
string v = card[field]?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(v))
|
|
{
|
|
bits.Add($"{field}: {v.Trim()}");
|
|
}
|
|
}
|
|
if (card["triggers"] is JArray tr)
|
|
{
|
|
string joined = string.Join(", ", tr.Select(t => t?.ToString()).Where(s => !string.IsNullOrWhiteSpace(s)));
|
|
if (!string.IsNullOrWhiteSpace(joined))
|
|
{
|
|
bits.Add("triggers: " + joined);
|
|
}
|
|
}
|
|
if (bits.Count == 0 || string.IsNullOrWhiteSpace(key))
|
|
{
|
|
return;
|
|
}
|
|
string text = $"{kind} {key}. " + string.Join(" ", bits);
|
|
string baseUrl = NormalizeBaseUrl(Config.LoadSettings()["base_url"]?.ToString());
|
|
string embedModel = Config.LoadSettings()["embed_model"]?.ToString()
|
|
?? Config.LoadAssistant(Config.DefaultPersonaId())["embed_model"]?.ToString();
|
|
await Memory.UpsertTextAsync(baseUrl, "card", key, text, "user", card, embedModel);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"IngestCardToMemory: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
public async Task<JObject> AssistentEnqueueWanted(Session session, string kind, string url, int version_id = 0, string title = null, JObject card = null)
|
|
{
|
|
await Task.CompletedTask;
|
|
kind = (kind ?? "lora").Trim().ToLowerInvariant();
|
|
if (kind is not ("lora" or "checkpoint" or "vae" or "embedding" or "controlnet" or "upscaler" or "clip"))
|
|
{
|
|
kind = "lora";
|
|
}
|
|
url = (url ?? "").Trim();
|
|
if (string.IsNullOrWhiteSpace(url) && version_id > 0)
|
|
{
|
|
url = $"https://civitai.red/models/0?modelVersionId={version_id}";
|
|
}
|
|
if (string.IsNullOrWhiteSpace(url))
|
|
{
|
|
return new JObject { ["error"] = "url or version_id required" };
|
|
}
|
|
if (version_id <= 0)
|
|
{
|
|
Match m = Regex.Match(url, @"modelVersionId=(\d+)", RegexOptions.IgnoreCase);
|
|
if (m.Success)
|
|
{
|
|
version_id = int.Parse(m.Groups[1].Value);
|
|
}
|
|
}
|
|
|
|
string path = WantedModelsPath();
|
|
Directory.CreateDirectory(Path.GetDirectoryName(path) ?? DataRoot());
|
|
Dictionary<string, List<WantedEntry>> sections = LoadWantedYaml(File.Exists(path) ? File.ReadAllText(path, Encoding.UTF8) : "");
|
|
|
|
if (version_id > 0)
|
|
{
|
|
foreach (List<WantedEntry> list in sections.Values)
|
|
{
|
|
if (list.Any(e => e.VersionId == version_id))
|
|
{
|
|
return new JObject { ["success"] = true, ["already"] = true, ["path"] = path, ["version_id"] = version_id };
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (List<WantedEntry> list in sections.Values)
|
|
{
|
|
if (list.Any(e => string.Equals(e.Url, url, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
return new JObject { ["success"] = true, ["already"] = true, ["path"] = path };
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!sections.TryGetValue(kind, out List<WantedEntry> bucket))
|
|
{
|
|
bucket = [];
|
|
sections[kind] = bucket;
|
|
}
|
|
bucket.Add(new WantedEntry { Url = url, Title = title, VersionId = version_id });
|
|
File.WriteAllText(path, WriteWantedYaml(sections), Encoding.UTF8);
|
|
|
|
if (card is not null && version_id > 0)
|
|
{
|
|
Directory.CreateDirectory(WantedCardsDir());
|
|
string draft = Path.Combine(WantedCardsDir(), $"{version_id}.assistent.json");
|
|
File.WriteAllText(draft, card.ToString(Newtonsoft.Json.Formatting.Indented), Encoding.UTF8);
|
|
}
|
|
return new JObject { ["success"] = true, ["path"] = path, ["version_id"] = version_id };
|
|
}
|
|
|
|
sealed class WantedEntry
|
|
{
|
|
public string Url;
|
|
public string Title;
|
|
public int VersionId;
|
|
}
|
|
|
|
static Dictionary<string, List<WantedEntry>> LoadWantedYaml(string raw)
|
|
{
|
|
Dictionary<string, List<WantedEntry>> sections = new(StringComparer.OrdinalIgnoreCase);
|
|
string currentKind = null;
|
|
WantedEntry cur = null;
|
|
void Flush()
|
|
{
|
|
if (cur is null || string.IsNullOrWhiteSpace(cur.Url) || string.IsNullOrWhiteSpace(currentKind))
|
|
{
|
|
cur = null;
|
|
return;
|
|
}
|
|
if (!sections.TryGetValue(currentKind, out List<WantedEntry> list))
|
|
{
|
|
list = [];
|
|
sections[currentKind] = list;
|
|
}
|
|
list.Add(cur);
|
|
cur = null;
|
|
}
|
|
foreach (string line in (raw ?? "").Split('\n'))
|
|
{
|
|
string t = line.TrimEnd();
|
|
if (string.IsNullOrWhiteSpace(t) || t.TrimStart().StartsWith('#'))
|
|
{
|
|
continue;
|
|
}
|
|
Match kindLine = Regex.Match(t, @"^([A-Za-z0-9_-]+):\s*$");
|
|
if (kindLine.Success && !t.TrimStart().StartsWith('-'))
|
|
{
|
|
Flush();
|
|
currentKind = kindLine.Groups[1].Value.Trim().ToLowerInvariant();
|
|
continue;
|
|
}
|
|
Match urlLine = Regex.Match(t, @"^\s*-\s*url:\s*[""']?(.+?)[""']?\s*$");
|
|
if (urlLine.Success)
|
|
{
|
|
Flush();
|
|
cur = new WantedEntry { Url = urlLine.Groups[1].Value.Trim() };
|
|
continue;
|
|
}
|
|
if (cur is null)
|
|
{
|
|
continue;
|
|
}
|
|
Match titleLine = Regex.Match(t, @"^\s*title:\s*[""']?(.+?)[""']?\s*$");
|
|
if (titleLine.Success)
|
|
{
|
|
cur.Title = titleLine.Groups[1].Value.Trim();
|
|
continue;
|
|
}
|
|
Match vidLine = Regex.Match(t, @"^\s*version_id:\s*(\d+)\s*$");
|
|
if (vidLine.Success && int.TryParse(vidLine.Groups[1].Value, out int vid))
|
|
{
|
|
cur.VersionId = vid;
|
|
}
|
|
}
|
|
Flush();
|
|
return sections;
|
|
}
|
|
|
|
static string WriteWantedYaml(Dictionary<string, List<WantedEntry>> sections)
|
|
{
|
|
StringBuilder sb = new();
|
|
sb.AppendLine("# Assistent wanted queue — merged into local models.yaml on gpu-rent up/capture");
|
|
string[] order = ["checkpoint", "lora", "vae", "embedding", "controlnet", "upscaler", "clip"];
|
|
HashSet<string> seen = new(StringComparer.OrdinalIgnoreCase);
|
|
foreach (string kind in order.Concat(sections.Keys.OrderBy(k => k, StringComparer.OrdinalIgnoreCase)))
|
|
{
|
|
if (!seen.Add(kind) || !sections.TryGetValue(kind, out List<WantedEntry> list) || list.Count == 0)
|
|
{
|
|
continue;
|
|
}
|
|
sb.AppendLine($"{kind}:");
|
|
foreach (WantedEntry e in list)
|
|
{
|
|
sb.AppendLine($" - url: \"{e.Url.Replace("\"", "%22")}\"");
|
|
if (!string.IsNullOrWhiteSpace(e.Title))
|
|
{
|
|
sb.AppendLine($" title: \"{e.Title.Replace("\"", "'")}\"");
|
|
}
|
|
if (e.VersionId > 0)
|
|
{
|
|
sb.AppendLine($" version_id: {e.VersionId}");
|
|
}
|
|
}
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
string TasteJsonPath() => Path.Combine(DataRoot(), "Assistent", "taste.json");
|
|
|
|
public async Task<JObject> AssistentGetTaste(Session session)
|
|
{
|
|
await Task.CompletedTask;
|
|
string path = TasteJsonPath();
|
|
if (!File.Exists(path))
|
|
{
|
|
return new JObject { ["success"] = true, ["taste"] = null };
|
|
}
|
|
try
|
|
{
|
|
JObject taste = JObject.Parse(File.ReadAllText(path, Encoding.UTF8));
|
|
return new JObject { ["success"] = true, ["taste"] = taste };
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new JObject { ["error"] = $"taste.json: {ex.Message}" };
|
|
}
|
|
}
|
|
|
|
public async Task<JObject> AssistentSaveTaste(Session session, JObject taste)
|
|
{
|
|
await Task.CompletedTask;
|
|
if (taste is null)
|
|
{
|
|
return new JObject { ["error"] = "taste required" };
|
|
}
|
|
if (taste["updated"] == null)
|
|
{
|
|
taste["updated"] = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
}
|
|
string dir = Path.Combine(DataRoot(), "Assistent");
|
|
Directory.CreateDirectory(dir);
|
|
string path = TasteJsonPath();
|
|
File.WriteAllText(path, taste.ToString(Newtonsoft.Json.Formatting.Indented), Encoding.UTF8);
|
|
return new JObject { ["success"] = true, ["path"] = path };
|
|
}
|
|
|
|
public async Task<JObject> AssistentGetCardMeta(Session session, string kind, string name, int version_id = 0, bool fetch = false)
|
|
{
|
|
string set = SetNameForKind(kind);
|
|
string weight = ModelWeightPath(set, name);
|
|
JObject civitai = null;
|
|
JArray exampleUrls = [];
|
|
JArray previewUrls = [];
|
|
bool hasSidecar = false;
|
|
string fetchError = null;
|
|
bool fetched = false;
|
|
|
|
if (!string.IsNullOrWhiteSpace(weight))
|
|
{
|
|
string stem = Path.GetFileNameWithoutExtension(weight);
|
|
string dir = Path.GetDirectoryName(weight);
|
|
string side = Path.Combine(dir ?? "", $"{stem}.civitai.json");
|
|
if (File.Exists(side))
|
|
{
|
|
hasSidecar = true;
|
|
try
|
|
{
|
|
civitai = JObject.Parse(File.ReadAllText(side, Encoding.UTF8));
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
foreach (string suffix in new[] { ".preview.jpg", ".preview.png", ".preview.jpeg", ".jpg", ".png", ".webp" })
|
|
{
|
|
string prev = Path.Combine(dir ?? "", stem + suffix);
|
|
if (File.Exists(prev))
|
|
{
|
|
// Swarm View path — relative URL works in the same origin browser session.
|
|
previewUrls.Add($"View/Models/{(kind == "lora" ? "Lora" : "Stable-Diffusion")}/{Path.GetFileName(prev)}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (civitai is not null)
|
|
{
|
|
if (version_id <= 0)
|
|
{
|
|
version_id = civitai["id"]?.Value<int?>() ?? 0;
|
|
}
|
|
CollectExampleUrls(civitai, exampleUrls);
|
|
}
|
|
|
|
string hash = null;
|
|
string trigger = null;
|
|
try
|
|
{
|
|
if (Program.T2IModelSets.TryGetValue(set, out T2IModelHandler h)
|
|
&& (h.Models.TryGetValue(name, out T2IModel m)
|
|
|| h.Models.TryGetValue(name.Replace('\\', '/'), out m)))
|
|
{
|
|
trigger = m.Metadata?.TriggerPhrase;
|
|
hash = m.Metadata?.Hash;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
if (fetch && civitai is null)
|
|
{
|
|
string apiKey = session.User.GetGenericData("civitai_api", "key") ?? "";
|
|
if (string.IsNullOrWhiteSpace(apiKey))
|
|
{
|
|
fetchError = "Civitai: нет ключа в User Settings";
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
JObject remote = null;
|
|
if (version_id > 0)
|
|
{
|
|
remote = await FetchCivitaiModelVersion(apiKey, version_id);
|
|
}
|
|
if (remote is null && !string.IsNullOrWhiteSpace(hash))
|
|
{
|
|
string sha = hash.Trim().ToLowerInvariant();
|
|
if (sha.StartsWith("sha256:"))
|
|
{
|
|
sha = sha["sha256:".Length..];
|
|
}
|
|
if (sha.Length == 64)
|
|
{
|
|
remote = await FetchCivitaiByHash(apiKey, sha);
|
|
}
|
|
else
|
|
{
|
|
fetchError ??= "Civitai: хеш модели не SHA256";
|
|
}
|
|
}
|
|
if (remote is not null)
|
|
{
|
|
civitai = remote;
|
|
fetched = true;
|
|
version_id = remote["id"]?.Value<int?>() ?? version_id;
|
|
CollectExampleUrls(remote, exampleUrls);
|
|
if (!string.IsNullOrWhiteSpace(weight))
|
|
{
|
|
try
|
|
{
|
|
string stem = Path.GetFileNameWithoutExtension(weight);
|
|
string dir = Path.GetDirectoryName(weight);
|
|
string side = Path.Combine(dir ?? "", $"{stem}.civitai.json");
|
|
File.WriteAllText(side, remote.ToString(Newtonsoft.Json.Formatting.Indented), Encoding.UTF8);
|
|
hasSidecar = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"AssistentGetCardMeta write sidecar: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
else if (fetchError is null)
|
|
{
|
|
fetchError = string.IsNullOrWhiteSpace(hash)
|
|
? "Civitai: нет hash и version_id"
|
|
: "Хеш не найден на Civitai";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
fetchError = $"Civitai: {ex.Message}";
|
|
}
|
|
}
|
|
}
|
|
|
|
JObject card = ReadCardObject(kind, name);
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["kind"] = kind,
|
|
["name"] = name,
|
|
["version_id"] = version_id,
|
|
["trigger_phrase"] = trigger,
|
|
["has_card"] = card is not null,
|
|
["has_sidecar"] = hasSidecar,
|
|
["fetched"] = fetched,
|
|
["fetch_error"] = fetchError,
|
|
["card"] = card,
|
|
["civitai"] = civitai,
|
|
["example_urls"] = exampleUrls,
|
|
["preview_urls"] = previewUrls,
|
|
["weight_path"] = weight,
|
|
["hash"] = hash,
|
|
};
|
|
}
|
|
|
|
static void CollectExampleUrls(JObject civitai, JArray exampleUrls)
|
|
{
|
|
if (civitai?["images"] is not JArray imgs)
|
|
{
|
|
return;
|
|
}
|
|
foreach (JToken img in imgs.Take(6))
|
|
{
|
|
string u = img?["url"]?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(u))
|
|
{
|
|
exampleUrls.Add(u);
|
|
}
|
|
}
|
|
}
|
|
|
|
async Task<JObject> FetchCivitaiByHash(string apiKey, string sha)
|
|
{
|
|
string[] hosts = ["civitai.red", "civitai.com"];
|
|
Exception last = null;
|
|
foreach (string host in hosts)
|
|
{
|
|
try
|
|
{
|
|
string url = $"https://{host}/api/v1/model-versions/by-hash/{sha}";
|
|
using HttpRequestMessage req = new(HttpMethod.Get, url);
|
|
if (!string.IsNullOrWhiteSpace(apiKey))
|
|
{
|
|
req.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey.Trim());
|
|
}
|
|
using HttpResponseMessage resp = await HttpClient.SendAsync(req);
|
|
string body = await resp.Content.ReadAsStringAsync();
|
|
if (resp.StatusCode == System.Net.HttpStatusCode.NotFound)
|
|
{
|
|
continue;
|
|
}
|
|
if (!resp.IsSuccessStatusCode)
|
|
{
|
|
last = new Exception($"HTTP {(int)resp.StatusCode}: {Clip(body, 160)}");
|
|
if ((int)resp.StatusCode is 401 or 403)
|
|
{
|
|
throw last;
|
|
}
|
|
continue;
|
|
}
|
|
return JObject.Parse(body);
|
|
}
|
|
catch (Exception ex) when (ex is not HttpRequestException && ex.Message.Contains("401"))
|
|
{
|
|
throw;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
last = ex;
|
|
}
|
|
}
|
|
if (last is not null)
|
|
{
|
|
throw last;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async Task<JObject> FetchCivitaiModelVersion(string apiKey, int versionId)
|
|
{
|
|
string[] hosts = ["civitai.red", "civitai.com"];
|
|
Exception last = null;
|
|
foreach (string host in hosts)
|
|
{
|
|
try
|
|
{
|
|
string url = $"https://{host}/api/v1/model-versions/{versionId}";
|
|
using HttpRequestMessage req = new(HttpMethod.Get, url);
|
|
if (!string.IsNullOrWhiteSpace(apiKey))
|
|
{
|
|
req.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey.Trim());
|
|
}
|
|
using HttpResponseMessage resp = await HttpClient.SendAsync(req);
|
|
string body = await resp.Content.ReadAsStringAsync();
|
|
if (!resp.IsSuccessStatusCode)
|
|
{
|
|
last = new Exception($"HTTP {(int)resp.StatusCode}: {Clip(body, 160)}");
|
|
if ((int)resp.StatusCode is 401 or 403)
|
|
{
|
|
throw last;
|
|
}
|
|
continue;
|
|
}
|
|
return JObject.Parse(body);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
last = ex;
|
|
if (ex.Message.Contains("401") || ex.Message.Contains("403"))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
if (last is not null)
|
|
{
|
|
throw last;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Server-side LoRA / checkpoint / wildcard inventory (not DOM scrape).
|
|
/// Pass rescan=true after downloads so new files appear (calls Program.RefreshAllModelSets).</summary>
|
|
public async Task<JObject> AssistentListInventory(Session session, bool rescan = false)
|
|
{
|
|
await Task.CompletedTask;
|
|
if (rescan)
|
|
{
|
|
try
|
|
{
|
|
Program.RefreshAllModelSets();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"AssistentListInventory rescan: {ex.Message}");
|
|
try
|
|
{
|
|
Program.ModelRefreshEvent?.Invoke();
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
Logs.Debug($"AssistentListInventory ModelRefreshEvent: {ex2.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
JArray loras = [];
|
|
JArray checkpoints = [];
|
|
JArray wildcards = [];
|
|
|
|
if (Program.T2IModelSets.TryGetValue("LoRA", out T2IModelHandler loraHandler))
|
|
{
|
|
foreach (T2IModel model in loraHandler.Models.Values
|
|
.OrderByDescending(m => LooksLikeKreaArch(m))
|
|
.ThenBy(m => m.Name)
|
|
.Take(CfgInt("max_loras_inventory", MaxLorasInInventoryFallback)))
|
|
{
|
|
loras.Add(BuildInventoryModelEntry(model, "lora"));
|
|
}
|
|
}
|
|
|
|
if (Program.T2IModelSets.TryGetValue("Stable-Diffusion", out T2IModelHandler ckptHandler))
|
|
{
|
|
foreach (T2IModel model in ckptHandler.Models.Values
|
|
.OrderByDescending(m => LooksLikeKreaArch(m))
|
|
.ThenBy(m => m.Name)
|
|
.Take(CfgInt("max_checkpoints_inventory", MaxCheckpointsInInventoryFallback)))
|
|
{
|
|
checkpoints.Add(BuildInventoryModelEntry(model, "checkpoint"));
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (string name in WildcardsHelper.ListFiles.OrderBy(n => n).Take(CfgInt("max_wildcards_inventory", MaxWildcardsInInventoryFallback)))
|
|
{
|
|
wildcards.Add(new JObject { ["name"] = name });
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"AssistentListInventory wildcards: {ex.Message}");
|
|
}
|
|
|
|
bool hasCivitaiKey = !string.IsNullOrWhiteSpace(session.User.GetGenericData("civitai_api", "key"));
|
|
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["loras"] = loras,
|
|
["checkpoints"] = checkpoints,
|
|
["wildcards"] = wildcards,
|
|
["has_civitai_key"] = hasCivitaiKey,
|
|
["rescanned"] = rescan,
|
|
["inventory_at"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
|
|
};
|
|
}
|
|
|
|
static bool LooksLikeKreaArch(T2IModel model)
|
|
{
|
|
string arch = model?.ModelClass?.ID ?? "";
|
|
string compat = model?.ModelClass?.CompatClass?.ID ?? "";
|
|
string name = model?.Name ?? "";
|
|
string blob = $"{arch} {compat} {name}".ToLowerInvariant();
|
|
return blob.Contains("krea");
|
|
}
|
|
|
|
JObject BuildInventoryModelEntry(T2IModel model, string kind)
|
|
{
|
|
string weight = null;
|
|
try { weight = model.RawFilePath; } catch { /* ignore */ }
|
|
string cardPath = CardPathForWeight(weight);
|
|
bool hasCard = !string.IsNullOrWhiteSpace(cardPath) && File.Exists(cardPath);
|
|
|
|
string usage = model.Metadata?.UsageHint;
|
|
string desc = model.Metadata?.Description;
|
|
try
|
|
{
|
|
if (string.IsNullOrWhiteSpace(desc) && !string.IsNullOrWhiteSpace(model.Description))
|
|
{
|
|
desc = model.Description;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// older Swarm builds
|
|
}
|
|
|
|
string blurb = null;
|
|
if (hasCard)
|
|
{
|
|
try
|
|
{
|
|
JObject card = JObject.Parse(File.ReadAllText(cardPath, Encoding.UTF8));
|
|
string fromCard = (card["notes"] ?? card["when"] ?? card["prompt_hint"])?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(fromCard))
|
|
{
|
|
blurb = Clip(fromCard.Trim(), CfgInt("inventory_blurb_max", InventoryBlurbMaxFallback));
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore bad card json
|
|
}
|
|
}
|
|
if (string.IsNullOrWhiteSpace(blurb))
|
|
{
|
|
string raw = !string.IsNullOrWhiteSpace(usage) ? usage : desc;
|
|
if (!string.IsNullOrWhiteSpace(raw))
|
|
{
|
|
blurb = Clip(CollapseWs(raw), CfgInt("inventory_blurb_max", InventoryBlurbMaxFallback));
|
|
}
|
|
}
|
|
|
|
JArray tags = null;
|
|
if (model.Metadata?.Tags is { Length: > 0 } tagArr)
|
|
{
|
|
tags = new JArray(tagArr.Where(t => !string.IsNullOrWhiteSpace(t)).Take(8));
|
|
}
|
|
|
|
string trigger = model.Metadata?.TriggerPhrase;
|
|
JArray triggers = null;
|
|
if (!string.IsNullOrWhiteSpace(trigger))
|
|
{
|
|
triggers = new JArray(trigger.Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).Take(12));
|
|
}
|
|
|
|
JObject entry = new()
|
|
{
|
|
["name"] = model.Name,
|
|
["title"] = model.Metadata?.Title ?? model.Title ?? model.Name,
|
|
["kind"] = kind,
|
|
["trigger_phrase"] = trigger,
|
|
["architecture"] = model.ModelClass?.ID,
|
|
["compat_class"] = model.ModelClass?.CompatClass?.ID,
|
|
["hash"] = model.Metadata?.Hash ?? "",
|
|
["has_card"] = hasCard,
|
|
["krea_likely"] = LooksLikeKreaArch(model),
|
|
};
|
|
if (!string.IsNullOrWhiteSpace(weight))
|
|
{
|
|
string stem = Path.GetFileNameWithoutExtension(weight);
|
|
string dir = Path.GetDirectoryName(weight);
|
|
string side = Path.Combine(dir ?? "", $"{stem}.civitai.json");
|
|
entry["has_sidecar"] = File.Exists(side);
|
|
foreach (string suffix in new[] { ".preview.jpg", ".preview.png", ".preview.jpeg", ".jpg", ".png", ".webp" })
|
|
{
|
|
string prev = Path.Combine(dir ?? "", stem + suffix);
|
|
if (File.Exists(prev))
|
|
{
|
|
string folder = kind == "lora" ? "Lora" : "Stable-Diffusion";
|
|
entry["preview_url"] = $"View/Models/{folder}/{Path.GetFileName(prev)}";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
entry["has_sidecar"] = false;
|
|
}
|
|
if (triggers is not null && triggers.Count > 0)
|
|
{
|
|
entry["triggers"] = triggers;
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(blurb))
|
|
{
|
|
entry["blurb"] = blurb;
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(usage))
|
|
{
|
|
entry["usage_hint"] = Clip(CollapseWs(usage), 120);
|
|
}
|
|
if (tags is not null && tags.Count > 0)
|
|
{
|
|
entry["tags"] = tags;
|
|
}
|
|
string defW = model.Metadata?.LoraDefaultWeight;
|
|
if (!string.IsNullOrWhiteSpace(defW) && kind == "lora")
|
|
{
|
|
entry["default_weight"] = defW;
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
static string CollapseWs(string text)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
{
|
|
return "";
|
|
}
|
|
return Regex.Replace(text.Trim(), @"\s+", " ");
|
|
}
|
|
|
|
/// <summary>Search Civitai for LoRAs (prefers Krea 2 base). Uses Swarm-stored civitai_api key.</summary>
|
|
public async Task<JObject> AssistentSearchCivitai(Session session, string query, int limit = 8)
|
|
{
|
|
string q = (query ?? "").Trim();
|
|
if (string.IsNullOrWhiteSpace(q))
|
|
{
|
|
return new JObject { ["error"] = "query is required" };
|
|
}
|
|
limit = Math.Clamp(limit, 1, 20);
|
|
string apiKey = session.User.GetGenericData("civitai_api", "key") ?? "";
|
|
HashSet<string> installedNames = CollectInstalledLoraNames();
|
|
HashSet<string> installedHashes = CollectInstalledLoraHashes();
|
|
|
|
string[] hosts = ["civitai.red", "civitai.com"];
|
|
Exception lastEx = null;
|
|
foreach (string host in hosts)
|
|
{
|
|
try
|
|
{
|
|
string url = $"https://{host}/api/v1/models?limit={limit}&types=LORA&query={Uri.EscapeDataString(q)}";
|
|
using HttpRequestMessage req = new(HttpMethod.Get, url);
|
|
if (!string.IsNullOrWhiteSpace(apiKey))
|
|
{
|
|
req.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey.Trim());
|
|
}
|
|
using HttpResponseMessage resp = await HttpClient.SendAsync(req);
|
|
string body = await resp.Content.ReadAsStringAsync();
|
|
if (!resp.IsSuccessStatusCode)
|
|
{
|
|
lastEx = new Exception($"HTTP {(int)resp.StatusCode}: {Clip(body, 200)}");
|
|
continue;
|
|
}
|
|
JObject parsed = JObject.Parse(body);
|
|
JArray items = parsed["items"] as JArray ?? [];
|
|
JArray results = [];
|
|
foreach (JToken item in items)
|
|
{
|
|
if (item is not JObject mo)
|
|
{
|
|
continue;
|
|
}
|
|
JObject card = BuildCivitaiCard(mo, installedNames, installedHashes);
|
|
if (card is not null)
|
|
{
|
|
results.Add(card);
|
|
}
|
|
}
|
|
// Prefer Krea-compatible first
|
|
JArray sorted = new(results.OrderByDescending(t => LooksLikeKrea(t["base_model"]?.ToString())).ThenBy(t => t["name"]?.ToString()));
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["query"] = q,
|
|
["host"] = host,
|
|
["results"] = sorted,
|
|
["has_civitai_key"] = !string.IsNullOrWhiteSpace(apiKey),
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
lastEx = ex;
|
|
}
|
|
}
|
|
return new JObject { ["error"] = $"Civitai search failed: {lastEx?.Message ?? "unknown"}" };
|
|
}
|
|
|
|
static bool LooksLikeKrea(string text) => !string.IsNullOrEmpty(text) && Regex.IsMatch(text, @"krea", RegexOptions.IgnoreCase);
|
|
|
|
static HashSet<string> CollectInstalledLoraNames()
|
|
{
|
|
HashSet<string> names = new(StringComparer.OrdinalIgnoreCase);
|
|
if (!Program.T2IModelSets.TryGetValue("LoRA", out T2IModelHandler handler))
|
|
{
|
|
return names;
|
|
}
|
|
foreach (T2IModel m in handler.Models.Values)
|
|
{
|
|
names.Add(m.Name);
|
|
string leaf = m.Name.Replace('\\', '/').AfterLast('/');
|
|
if (!string.IsNullOrEmpty(leaf))
|
|
{
|
|
names.Add(leaf);
|
|
names.Add(Path.GetFileNameWithoutExtension(leaf));
|
|
}
|
|
}
|
|
return names;
|
|
}
|
|
|
|
static HashSet<string> CollectInstalledLoraHashes()
|
|
{
|
|
HashSet<string> hashes = new(StringComparer.OrdinalIgnoreCase);
|
|
if (!Program.T2IModelSets.TryGetValue("LoRA", out T2IModelHandler handler))
|
|
{
|
|
return hashes;
|
|
}
|
|
foreach (T2IModel m in handler.Models.Values)
|
|
{
|
|
string h = m.Metadata?.Hash;
|
|
if (!string.IsNullOrWhiteSpace(h))
|
|
{
|
|
hashes.Add(h.Trim().ToLowerInvariant());
|
|
}
|
|
}
|
|
return hashes;
|
|
}
|
|
|
|
static JObject BuildCivitaiCard(JObject model, HashSet<string> installedNames, HashSet<string> installedHashes)
|
|
{
|
|
string name = model["name"]?.ToString() ?? "";
|
|
JArray versions = model["modelVersions"] as JArray;
|
|
JObject ver = versions?.FirstOrDefault() as JObject;
|
|
if (ver is null)
|
|
{
|
|
return null;
|
|
}
|
|
string baseModel = ver["baseModel"]?.ToString() ?? "";
|
|
JArray trained = ver["trainedWords"] as JArray ?? [];
|
|
List<string> triggers = trained.Select(t => t?.ToString()).Where(s => !string.IsNullOrWhiteSpace(s)).Take(8).ToList();
|
|
JObject file = null;
|
|
foreach (JToken f in ver["files"] as JArray ?? [])
|
|
{
|
|
if (f is JObject fo && (fo["primary"]?.Value<bool>() == true || (fo["name"]?.ToString() ?? "").EndsWith(".safetensors", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
file = fo;
|
|
break;
|
|
}
|
|
}
|
|
file ??= (ver["files"] as JArray)?.FirstOrDefault() as JObject;
|
|
string downloadUrl = file?["downloadUrl"]?.ToString() ?? ver["downloadUrl"]?.ToString() ?? "";
|
|
string fileName = file?["name"]?.ToString() ?? "";
|
|
string sha = file?["hashes"]?["SHA256"]?.ToString() ?? file?["hashes"]?["AutoV2"]?.ToString() ?? "";
|
|
string saveName = string.IsNullOrWhiteSpace(fileName)
|
|
? Regex.Replace(name, @"[^\w\-.]+", "_").Trim('_')
|
|
: Path.GetFileNameWithoutExtension(fileName);
|
|
|
|
bool already = false;
|
|
if (!string.IsNullOrWhiteSpace(sha) && installedHashes.Contains(sha.Trim().ToLowerInvariant()))
|
|
{
|
|
already = true;
|
|
}
|
|
else if (installedNames.Contains(saveName) || installedNames.Contains(name) || installedNames.Contains(fileName))
|
|
{
|
|
already = true;
|
|
}
|
|
|
|
return new JObject
|
|
{
|
|
["id"] = model["id"],
|
|
["version_id"] = ver["id"],
|
|
["name"] = name,
|
|
["base_model"] = baseModel,
|
|
["krea_likely"] = LooksLikeKrea(baseModel),
|
|
["triggers"] = new JArray(triggers),
|
|
["download_url"] = downloadUrl,
|
|
["file_name"] = saveName,
|
|
["sha256"] = sha,
|
|
["already_installed"] = already,
|
|
["n_sfw"] = model["nsfw"]?.Value<bool>() ?? false,
|
|
};
|
|
}
|
|
|
|
List<JObject> BuildOllamaMessages(string packName, bool includeBase, string contextJson, JArray userMessages, string extraSystem = null, string personaId = null, IEnumerable<string> skillIds = null)
|
|
{
|
|
List<JObject> ollamaMessages = [];
|
|
StringBuilder system = new();
|
|
string pid = AssistentConfig.SafeId(personaId) ?? Config.DefaultPersonaId();
|
|
|
|
if (includeBase)
|
|
{
|
|
string core = Config.LoadCorePrompt(pid);
|
|
if (!string.IsNullOrWhiteSpace(core))
|
|
{
|
|
system.AppendLine(core);
|
|
}
|
|
}
|
|
|
|
JObject exact = Config.LoadExact(pid);
|
|
if (exact is not null && exact.Count > 0)
|
|
{
|
|
system.AppendLine();
|
|
system.AppendLine("## Exact memory (canonical KV — always trust over RAG guesses)");
|
|
system.AppendLine("```json");
|
|
system.AppendLine(exact.ToString(Newtonsoft.Json.Formatting.None));
|
|
system.AppendLine("```");
|
|
}
|
|
|
|
foreach (string skillId in skillIds ?? Config.ResolveEnabledSkills(pid, null))
|
|
{
|
|
string skillText = Config.LoadSkillPrompt(pid, skillId);
|
|
if (!string.IsNullOrWhiteSpace(skillText))
|
|
{
|
|
system.AppendLine();
|
|
system.AppendLine($"## Skill: {skillId}");
|
|
system.AppendLine(skillText);
|
|
}
|
|
}
|
|
|
|
string identity = Config.RenderIdentityBlock(pid);
|
|
if (!string.IsNullOrWhiteSpace(identity))
|
|
{
|
|
system.AppendLine();
|
|
system.AppendLine(identity);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(packName) && packName != "base_krea2" && packName != "core")
|
|
{
|
|
string situational = Config.LoadPackPrompt(pid, packName);
|
|
if (!string.IsNullOrWhiteSpace(situational))
|
|
{
|
|
system.AppendLine();
|
|
system.AppendLine($"## Active mode: {packName}");
|
|
system.AppendLine(situational);
|
|
}
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(contextJson))
|
|
{
|
|
system.AppendLine();
|
|
system.AppendLine("## Live SwarmUI context (JSON — trust this over guesses)");
|
|
system.AppendLine("```json");
|
|
system.AppendLine(contextJson);
|
|
system.AppendLine("```");
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(extraSystem))
|
|
{
|
|
system.AppendLine();
|
|
system.AppendLine(extraSystem);
|
|
}
|
|
if (system.Length > 0)
|
|
{
|
|
ollamaMessages.Add(new JObject
|
|
{
|
|
["role"] = "system",
|
|
["content"] = system.ToString(),
|
|
});
|
|
}
|
|
foreach (JToken msg in userMessages ?? [])
|
|
{
|
|
if (msg is not JObject mo)
|
|
{
|
|
continue;
|
|
}
|
|
JObject copy = new()
|
|
{
|
|
["role"] = mo["role"]?.ToString() ?? "user",
|
|
["content"] = mo["content"]?.ToString() ?? "",
|
|
};
|
|
if (mo["images"] is JArray images && images.Count > 0)
|
|
{
|
|
copy["images"] = images;
|
|
}
|
|
ollamaMessages.Add(copy);
|
|
}
|
|
return ollamaMessages;
|
|
}
|
|
|
|
string ResolvePersonaPrompt(string personaId) => Config.RenderIdentityBlock(personaId);
|
|
|
|
static JObject TryParsePatch(string reply)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(reply))
|
|
{
|
|
return null;
|
|
}
|
|
foreach (Match match in JsonFenceRe.Matches(reply))
|
|
{
|
|
string raw = match.Groups[1].Value.Trim();
|
|
try
|
|
{
|
|
JObject obj = JObject.Parse(raw);
|
|
if (obj is not null && (obj["prompt"] != null || obj["loras"] != null || obj["width"] != null
|
|
|| obj["height"] != null || obj["steps"] != null || obj["cfg"] != null
|
|
|| obj["seed"] != null || obj["sigma_shift"] != null || obj["sampler"] != null
|
|
|| obj["actions"] != null || obj["search_query"] != null || obj["civitai_query"] != null
|
|
|| obj["use_init_image"] != null || obj["clear_init_image"] != null
|
|
|| obj["init_creativity"] != null || obj["denoise"] != null
|
|
|| obj["use_mask_image"] != null || obj["clear_mask_image"] != null
|
|
|| obj["mask_blur"] != null || obj["mask_grow"] != null
|
|
|| obj["look_at"] != null || obj["vision_from"] != null || obj["vision_slots"] != null
|
|
|| obj["slot_to_init"] != null || obj["slot_to_mask"] != null
|
|
|| obj["snapshot_generate"] != null || obj["select_slot"] != null
|
|
|| obj["aspect"] != null || obj["images"] != null || obj["batch"] != null
|
|
|| obj["vary"] != null || obj["lock_seed"] != null
|
|
|| obj["creativity"] != null || obj["intensity"] != null
|
|
|| obj["complexity"] != null || obj["movement"] != null
|
|
|| obj["clear_prompt_images"] != null || obj["slot_to_prompt_image"] != null
|
|
|| obj["pack"] != null || obj["memories"] != null || obj["memory"] != null))
|
|
{
|
|
return obj;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// not json
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static string ExtractSearchQuery(JObject patch)
|
|
{
|
|
if (patch is null)
|
|
{
|
|
return null;
|
|
}
|
|
string q = (patch["search_query"] ?? patch["civitai_query"])?.ToString()?.Trim();
|
|
if (!string.IsNullOrWhiteSpace(q))
|
|
{
|
|
return q;
|
|
}
|
|
if (patch["actions"] is JArray acts)
|
|
{
|
|
foreach (JToken a in acts)
|
|
{
|
|
if (string.Equals(a?.ToString(), "search_civitai", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return q; // may still be null — caller checks
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static bool WantsCivitaiSearch(JObject patch)
|
|
{
|
|
if (patch is null)
|
|
{
|
|
return false;
|
|
}
|
|
return !string.IsNullOrWhiteSpace(ExtractSearchQuery(patch));
|
|
}
|
|
|
|
static void ExtractChatPayload(JObject raw, ref string baseUrl, ref string model, ref string pack, ref bool includeBase, out JArray userMessages, out string contextJson, out string persona, out JArray skills)
|
|
{
|
|
JObject whole = raw ?? [];
|
|
JObject nested = whole["raw"] as JObject;
|
|
if (string.IsNullOrWhiteSpace(baseUrl))
|
|
{
|
|
baseUrl = whole["base_url"]?.ToString()
|
|
?? whole["baseUrl"]?.ToString()
|
|
?? nested?["base_url"]?.ToString()
|
|
?? nested?["baseUrl"]?.ToString();
|
|
}
|
|
if (string.IsNullOrWhiteSpace(model))
|
|
{
|
|
model = whole["model"]?.ToString() ?? nested?["model"]?.ToString();
|
|
}
|
|
if (string.IsNullOrWhiteSpace(pack))
|
|
{
|
|
pack = whole["pack"]?.ToString() ?? nested?["pack"]?.ToString();
|
|
}
|
|
if (whole["includeBase"] is not null)
|
|
{
|
|
includeBase = whole.Value<bool?>("includeBase") ?? includeBase;
|
|
}
|
|
userMessages = (whole["messages"] as JArray) ?? (nested?["messages"] as JArray);
|
|
contextJson = whole["context_json"]?.ToString() ?? nested?["context_json"]?.ToString();
|
|
persona = whole["persona"]?.ToString() ?? nested?["persona"]?.ToString() ?? "neutral";
|
|
skills = (whole["skills"] as JArray) ?? (nested?["skills"] as JArray);
|
|
}
|
|
|
|
async Task<(string reply, JObject raw, JArray civitaiResults)> RunChatWithHops(
|
|
Session session,
|
|
string root,
|
|
string modelName,
|
|
string packName,
|
|
bool includeBase,
|
|
string contextJson,
|
|
JArray userMessages,
|
|
Func<string, Task> onDelta = null,
|
|
Func<int, Task> onHopStart = null,
|
|
string personaId = null,
|
|
JArray skillIds = null,
|
|
string embedModel = null)
|
|
{
|
|
string pid = AssistentConfig.SafeId(personaId) ?? Config.DefaultPersonaId();
|
|
List<string> skills = Config.ResolveEnabledSkills(pid, skillIds);
|
|
string embed = string.IsNullOrWhiteSpace(embedModel)
|
|
? (Config.LoadSettings()["embed_model"]?.ToString()
|
|
?? Config.LoadAssistant(pid)["embed_model"]?.ToString()
|
|
?? "nomic-embed-text")
|
|
: embedModel;
|
|
|
|
try
|
|
{
|
|
await Memory.EnsureSeedAsync(root, Config, embed);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"Assistent memory seed: {ex.Message}");
|
|
}
|
|
|
|
string retrieveQuery = BuildRetrieveQuery(userMessages, contextJson);
|
|
JArray hits = [];
|
|
try
|
|
{
|
|
int topK = Config.LoadAssistant(pid)["memory_top_k"]?.Value<int?>() ?? 10;
|
|
hits = await Memory.RetrieveAsync(root, retrieveQuery, topK, embed);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"Assistent memory retrieve: {ex.Message}");
|
|
}
|
|
|
|
string enrichedContext = InjectMemoryHits(contextJson, hits, Config.LoadExact(pid));
|
|
List<JObject> messages = BuildOllamaMessages(packName, includeBase, enrichedContext, userMessages, personaId: pid, skillIds: skills);
|
|
JArray civitaiResults = [];
|
|
string reply = "";
|
|
JObject lastRaw = null;
|
|
int maxHops = CfgInt("max_civitai_hops", MaxCivitaiHopsFallback);
|
|
for (int hop = 0; hop < maxHops; hop++)
|
|
{
|
|
if (onHopStart is not null)
|
|
{
|
|
await onHopStart(hop);
|
|
}
|
|
(reply, lastRaw) = await CallOllamaChat(root, modelName, messages, stream: onDelta is not null, onDelta, pid);
|
|
JObject patch = TryParsePatch(reply);
|
|
await ApplyMemoryActions(root, patch, embed);
|
|
if (hop + 1 >= maxHops || !WantsCivitaiSearch(patch))
|
|
{
|
|
break;
|
|
}
|
|
string query = ExtractSearchQuery(patch);
|
|
if (string.IsNullOrWhiteSpace(query))
|
|
{
|
|
break;
|
|
}
|
|
JObject search = await AssistentSearchCivitai(session, query, 8);
|
|
if (search["error"] is not null)
|
|
{
|
|
messages.Add(new JObject { ["role"] = "assistant", ["content"] = reply });
|
|
messages.Add(new JObject
|
|
{
|
|
["role"] = "user",
|
|
["content"] = $"Civitai search failed: {search["error"]}. Continue without download — use only available_loras from context.",
|
|
});
|
|
continue;
|
|
}
|
|
civitaiResults = search["results"] as JArray ?? [];
|
|
messages.Add(new JObject { ["role"] = "assistant", ["content"] = reply });
|
|
messages.Add(new JObject
|
|
{
|
|
["role"] = "user",
|
|
["content"] =
|
|
"Civitai search results (JSON). Prefer `krea_likely: true`. Do NOT download yourself — the UI shows Confirm cards. " +
|
|
"Pick useful LoRAs from results or available_loras, emit a normal patch (prompt/loras). " +
|
|
"Omit search_civitai from actions unless you need a different query.\n```json\n" +
|
|
civitaiResults.ToString(Newtonsoft.Json.Formatting.None) + "\n```",
|
|
});
|
|
}
|
|
return (reply, lastRaw, civitaiResults);
|
|
}
|
|
|
|
static string BuildRetrieveQuery(JArray userMessages, string contextJson)
|
|
{
|
|
StringBuilder sb = new();
|
|
if (!string.IsNullOrWhiteSpace(contextJson))
|
|
{
|
|
try
|
|
{
|
|
JObject ctx = JObject.Parse(contextJson);
|
|
string ckpt = ctx["checkpoint"]?.ToString() ?? ctx["current_model"]?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(ckpt))
|
|
{
|
|
sb.Append(ckpt).Append(' ');
|
|
}
|
|
if (ctx["enabled_loras"] is JArray en)
|
|
{
|
|
foreach (JToken t in en.Take(8))
|
|
{
|
|
string n = t?["name"]?.ToString() ?? t?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(n))
|
|
{
|
|
sb.Append(n).Append(' ');
|
|
}
|
|
}
|
|
}
|
|
if (ctx["krea_profile"] != null)
|
|
{
|
|
sb.Append("krea ").Append(ctx["krea_profile"]).Append(' ');
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
foreach (JToken msg in (userMessages ?? []).Reverse().Take(2))
|
|
{
|
|
if (msg is JObject mo && string.Equals(mo["role"]?.ToString(), "user", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
sb.Append(mo["content"]?.ToString()).Append(' ');
|
|
}
|
|
}
|
|
string q = CollapseWs(sb.ToString());
|
|
return string.IsNullOrWhiteSpace(q) ? "krea2 prompting" : q;
|
|
}
|
|
|
|
static string InjectMemoryHits(string contextJson, JArray hits, JObject exact = null)
|
|
{
|
|
JObject ctx;
|
|
try
|
|
{
|
|
ctx = string.IsNullOrWhiteSpace(contextJson) ? new JObject() : JObject.Parse(contextJson);
|
|
}
|
|
catch
|
|
{
|
|
ctx = new JObject { ["_raw_context"] = contextJson };
|
|
}
|
|
ctx["memory_hits"] = hits ?? new JArray();
|
|
if (exact is not null && exact.Count > 0 && ctx["exact"] is null)
|
|
{
|
|
ctx["exact"] = exact;
|
|
}
|
|
if (ctx["session_exact"] is null)
|
|
{
|
|
ctx["session_exact"] = new JObject();
|
|
}
|
|
if (ctx["recommended_params"] is null && exact?["generation"] is JObject gen)
|
|
{
|
|
JObject rec = new();
|
|
foreach (string key in new[] { "steps", "cfg", "sigma_shift", "aspect", "images" })
|
|
{
|
|
if (gen[key] is not null)
|
|
{
|
|
rec[key] = gen[key].DeepClone();
|
|
}
|
|
}
|
|
if (rec.Count > 0)
|
|
{
|
|
ctx["recommended_params"] = rec;
|
|
}
|
|
}
|
|
// Slim inventory for LLM: keep enabled + current, drop full dump if present
|
|
if (ctx["available_loras"] is JArray allLoras && allLoras.Count > 24)
|
|
{
|
|
HashSet<string> keep = new(StringComparer.OrdinalIgnoreCase);
|
|
if (ctx["enabled_loras"] is JArray en)
|
|
{
|
|
foreach (JToken t in en)
|
|
{
|
|
string n = t?["name"]?.ToString() ?? t?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(n))
|
|
{
|
|
keep.Add(n);
|
|
}
|
|
}
|
|
}
|
|
foreach (JToken hit in hits ?? [])
|
|
{
|
|
if (string.Equals(hit?["kind"]?.ToString(), "lora", StringComparison.OrdinalIgnoreCase)
|
|
|| string.Equals(hit?["kind"]?.ToString(), "card", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
string k = hit?["key"]?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(k))
|
|
{
|
|
keep.Add(k);
|
|
}
|
|
}
|
|
}
|
|
JArray slim = [];
|
|
foreach (JToken t in allLoras)
|
|
{
|
|
string n = t?["name"]?.ToString();
|
|
if (!string.IsNullOrWhiteSpace(n) && (keep.Contains(n) || slim.Count < 12))
|
|
{
|
|
if (keep.Contains(n) || t?["krea_likely"]?.Value<bool>() == true)
|
|
{
|
|
slim.Add(t);
|
|
}
|
|
}
|
|
}
|
|
if (slim.Count == 0)
|
|
{
|
|
foreach (JToken t in allLoras.Take(12))
|
|
{
|
|
slim.Add(t);
|
|
}
|
|
}
|
|
ctx["available_loras"] = slim;
|
|
ctx["available_loras_truncated"] = true;
|
|
ctx["available_loras_total"] = allLoras.Count;
|
|
}
|
|
return ctx.ToString(Newtonsoft.Json.Formatting.None);
|
|
}
|
|
|
|
async Task ApplyMemoryActions(string root, JObject patch, string embedModel)
|
|
{
|
|
if (patch is null || Memory is null)
|
|
{
|
|
return;
|
|
}
|
|
bool upsert = false, forget = false;
|
|
if (patch["actions"] is JArray acts)
|
|
{
|
|
foreach (JToken a in acts)
|
|
{
|
|
string s = a?.ToString() ?? "";
|
|
if (string.Equals(s, "memory_upsert", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
upsert = true;
|
|
}
|
|
if (string.Equals(s, "memory_forget", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
forget = true;
|
|
}
|
|
}
|
|
}
|
|
JArray memories = patch["memories"] as JArray;
|
|
if (memories is null || memories.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
foreach (JToken t in memories)
|
|
{
|
|
if (t is not JObject mo)
|
|
{
|
|
continue;
|
|
}
|
|
string kind = mo["kind"]?.ToString() ?? "note";
|
|
string key = mo["key"]?.ToString() ?? "";
|
|
string text = mo["text"]?.ToString() ?? "";
|
|
try
|
|
{
|
|
if (forget && string.IsNullOrWhiteSpace(text))
|
|
{
|
|
Memory.Forget(kind, key);
|
|
}
|
|
else if (upsert || !string.IsNullOrWhiteSpace(text))
|
|
{
|
|
await Memory.UpsertTextAsync(root, kind, key, text, "user", mo, embedModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logs.Debug($"ApplyMemoryActions: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
async Task<(string reply, JObject raw)> CallOllamaChat(
|
|
string root,
|
|
string modelName,
|
|
List<JObject> ollamaMessages,
|
|
bool stream,
|
|
Func<string, Task> onDelta,
|
|
string personaId = null)
|
|
{
|
|
int numCtx = Config.LoadAssistant(AssistentConfig.SafeId(personaId) ?? Config.DefaultPersonaId())["num_ctx"]?.Value<int?>()
|
|
?? DefaultNumCtxFallback;
|
|
JObject payload = new()
|
|
{
|
|
["model"] = modelName,
|
|
["stream"] = stream,
|
|
["messages"] = new JArray(ollamaMessages),
|
|
["options"] = new JObject
|
|
{
|
|
["num_ctx"] = numCtx,
|
|
},
|
|
["keep_alive"] = "15m",
|
|
};
|
|
using StringContent content = new(payload.ToString(Newtonsoft.Json.Formatting.None), Encoding.UTF8, "application/json");
|
|
using HttpRequestMessage req = new(HttpMethod.Post, $"{root}/api/chat") { Content = content };
|
|
using HttpResponseMessage resp = await HttpClient.SendAsync(req, stream
|
|
? HttpCompletionOption.ResponseHeadersRead
|
|
: HttpCompletionOption.ResponseContentRead);
|
|
if (!resp.IsSuccessStatusCode)
|
|
{
|
|
string errBody = await resp.Content.ReadAsStringAsync();
|
|
throw new Exception($"Ollama /api/chat HTTP {(int)resp.StatusCode}: {Clip(errBody, 800)}");
|
|
}
|
|
if (!stream)
|
|
{
|
|
string body = await resp.Content.ReadAsStringAsync();
|
|
JObject parsed = JObject.Parse(body);
|
|
string reply = parsed["message"]?["content"]?.ToString() ?? parsed["response"]?.ToString() ?? "";
|
|
return (reply, parsed);
|
|
}
|
|
StringBuilder full = new();
|
|
await using Stream streamBody = await resp.Content.ReadAsStreamAsync();
|
|
using StreamReader reader = new(streamBody, Encoding.UTF8);
|
|
JObject last = null;
|
|
while (true)
|
|
{
|
|
string line = await reader.ReadLineAsync();
|
|
if (line is null)
|
|
{
|
|
break;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(line))
|
|
{
|
|
continue;
|
|
}
|
|
JObject chunk = JObject.Parse(line);
|
|
last = chunk;
|
|
string delta = chunk["message"]?["content"]?.ToString() ?? "";
|
|
if (!string.IsNullOrEmpty(delta))
|
|
{
|
|
full.Append(delta);
|
|
if (onDelta is not null)
|
|
{
|
|
await onDelta(delta);
|
|
}
|
|
}
|
|
if (chunk["done"]?.Value<bool>() == true)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return (full.ToString(), last ?? new JObject());
|
|
}
|
|
|
|
/// <summary>
|
|
/// SwarmUI passes the whole request as the JObject param (not only a nested key).
|
|
/// Support both flat fields and legacy nested <c>raw</c>.
|
|
/// </summary>
|
|
// ExtractChatPayload defined above
|
|
|
|
/// <summary>Proxy to Ollama /api/chat (non-stream), with optional Civitai search hop.</summary>
|
|
public async Task<JObject> AssistentChat(Session session, string baseUrl, string model, string pack, bool includeBase, JObject raw)
|
|
{
|
|
ExtractChatPayload(raw, ref baseUrl, ref model, ref pack, ref includeBase, out JArray userMessages, out string contextJson, out string persona, out JArray skills);
|
|
string root = NormalizeBaseUrl(baseUrl);
|
|
string modelName = (model ?? "").Trim();
|
|
if (string.IsNullOrWhiteSpace(modelName))
|
|
{
|
|
return new JObject { ["error"] = "model is required" };
|
|
}
|
|
if (userMessages is null || userMessages.Count == 0)
|
|
{
|
|
return new JObject { ["error"] = "messages required" };
|
|
}
|
|
string packName = (pack ?? "write_prompt").Trim();
|
|
string embedModel = raw?["embed_model"]?.ToString() ?? Config.LoadSettings()["embed_model"]?.ToString();
|
|
try
|
|
{
|
|
(string reply, JObject parsed, JArray civitai) = await RunChatWithHops(
|
|
session, root, modelName, packName, includeBase, contextJson, userMessages, personaId: persona, skillIds: skills, embedModel: embedModel);
|
|
return new JObject
|
|
{
|
|
["success"] = true,
|
|
["reply"] = reply,
|
|
["model"] = modelName,
|
|
["pack"] = packName,
|
|
["persona"] = persona,
|
|
["raw"] = parsed,
|
|
["civitai_results"] = civitai,
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new JObject { ["error"] = $"Ollama chat failed: {ex.Message}" };
|
|
}
|
|
}
|
|
|
|
/// <summary>WebSocket streaming chat (Ollama stream:true) + Civitai hops.</summary>
|
|
public async Task<JObject> AssistentChatWS(Session session, WebSocket ws, string baseUrl, string model, string pack, bool includeBase, JObject raw)
|
|
{
|
|
ExtractChatPayload(raw, ref baseUrl, ref model, ref pack, ref includeBase, out JArray userMessages, out string contextJson, out string persona, out JArray skills);
|
|
string root = NormalizeBaseUrl(baseUrl);
|
|
string modelName = (model ?? "").Trim();
|
|
if (string.IsNullOrWhiteSpace(modelName))
|
|
{
|
|
await ws.SendJson(new JObject { ["error"] = "model is required" }, API.WebsocketTimeout);
|
|
return null;
|
|
}
|
|
if (userMessages is null || userMessages.Count == 0)
|
|
{
|
|
await ws.SendJson(new JObject { ["error"] = "messages required" }, API.WebsocketTimeout);
|
|
return null;
|
|
}
|
|
string packName = (pack ?? "write_prompt").Trim();
|
|
string embedModel = raw?["embed_model"]?.ToString() ?? Config.LoadSettings()["embed_model"]?.ToString();
|
|
try
|
|
{
|
|
if (ws.State == WebSocketState.Open)
|
|
{
|
|
await ws.SendJson(new JObject
|
|
{
|
|
["phase"] = "waiting_ollama",
|
|
["notice"] = "Loading model into GPU…",
|
|
}, API.WebsocketTimeout);
|
|
}
|
|
async Task OnDelta(string delta)
|
|
{
|
|
if (ws.State == WebSocketState.Open)
|
|
{
|
|
await ws.SendJson(new JObject { ["delta"] = delta }, API.WebsocketTimeout);
|
|
}
|
|
}
|
|
async Task OnHopStart(int hop)
|
|
{
|
|
if (ws.State == WebSocketState.Open && hop > 0)
|
|
{
|
|
await ws.SendJson(new JObject
|
|
{
|
|
["clear_stream"] = true,
|
|
["hop"] = hop + 1,
|
|
["notice"] = "Civitai search done — refining…",
|
|
}, API.WebsocketTimeout);
|
|
}
|
|
}
|
|
(string reply, JObject parsed, JArray civitai) = await RunChatWithHops(
|
|
session, root, modelName, packName, includeBase, contextJson, userMessages, OnDelta, OnHopStart, persona, skills, embedModel);
|
|
await ws.SendJson(new JObject
|
|
{
|
|
["success"] = true,
|
|
["done"] = true,
|
|
["reply"] = reply,
|
|
["model"] = modelName,
|
|
["pack"] = packName,
|
|
["persona"] = persona,
|
|
["raw"] = parsed,
|
|
["civitai_results"] = civitai,
|
|
}, API.WebsocketTimeout);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await ws.SendJson(new JObject { ["error"] = $"Ollama chat failed: {ex.Message}" }, API.WebsocketTimeout);
|
|
}
|
|
return null;
|
|
}
|
|
}
|