@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/studio-hhvs4sdg.js

@@ -0,0 +1,195 @@
+import {
+  getPlatform2
+} from "./studio-6nzaktvy.js";
+import {
+  SETTINGS,
+  readStoredSetting,
+  hasSetting,
+  onSettingsChanged,
+  setSetting,
+  setSettings,
+  clearSettings
+} from "./studio-y9zedyjn.js";
+
+// src/services/ai-settings.ts
+function getOpenAiKey() {
+  return readStoredSetting(SETTINGS.aiOpenAiKey);
+}
+function setOpenAiKey(key) {
+  setSetting(SETTINGS.aiOpenAiKey, key || "");
+}
+function hasOpenAiKey() {
+  return hasSetting(SETTINGS.aiOpenAiKey);
+}
+function getBaseUrl() {
+  return readStoredSetting(SETTINGS.aiBaseUrl);
+}
+function storedModel() {
+  return readStoredSetting(SETTINGS.aiModel);
+}
+function setModel(modelId) {
+  setSetting(SETTINGS.aiModel, modelId || "");
+}
+function saveAiProvider(provider) {
+  setSettings([
+    [SETTINGS.aiOpenAiKey, provider.apiKey],
+    [SETTINGS.aiBaseUrl, provider.baseUrl],
+    [SETTINGS.aiModel, provider.model]
+  ]);
+}
+function clearAiProvider() {
+  clearSettings([SETTINGS.aiOpenAiKey, SETTINGS.aiBaseUrl, SETTINGS.aiModel]);
+}
+
+// src/services/ai-models.ts
+function aiConnection() {
+  return { apiKey: getOpenAiKey(), baseUrl: getBaseUrl() };
+}
+function fingerprint(credentials) {
+  return `${credentials.apiKey}\x00${credentials.baseUrl}`;
+}
+var cache = null;
+var cacheKey = "";
+var proxyConfigured = false;
+var proxyManaged = false;
+var proxyDefaultModel = "";
+var proxyCode;
+var proxyProbe = null;
+var probeListeners = new Set;
+var PROBE_STALE_MS = 600000;
+var probeSettledAt = 0;
+var probeRefreshInstalled = false;
+function resetModelCache() {
+  cache = null;
+  cacheKey = "";
+  proxyConfigured = false;
+  proxyManaged = false;
+  proxyDefaultModel = "";
+  proxyCode = undefined;
+  proxyProbe = null;
+  probeSettledAt = 0;
+}
+var CONNECTION_KEYS = new Set([
+  SETTINGS.aiOpenAiKey.key,
+  SETTINGS.aiBaseUrl.key,
+  SETTINGS.cfToken.key,
+  SETTINGS.cfAccountId.key
+]);
+onSettingsChanged((keys) => {
+  if (keys.some((key) => CONNECTION_KEYS.has(key))) {
+    resetModelCache();
+  }
+});
+function cachedModels(credentials) {
+  return cache && cacheKey === fingerprint(credentials) ? cache : null;
+}
+function cachedModel(id) {
+  return cache?.find((model) => model.id === id);
+}
+function modelToolSupport(id) {
+  return cachedModel(id)?.toolSupport;
+}
+function modelContextWindow(id) {
+  return cachedModel(id)?.contextWindow;
+}
+function ensureProxyProbe(onSettled) {
+  if (onSettled) {
+    probeListeners.add(onSettled);
+  }
+  proxyProbe ??= fetchAvailableModels({ force: true }).catch(() => {}).then(() => {
+    probeSettledAt = Date.now();
+    for (const notify of probeListeners) {
+      notify();
+    }
+  });
+}
+function refreshStaleProbe() {
+  if (!proxyManaged || probeSettledAt === 0 || Date.now() - probeSettledAt < PROBE_STALE_MS) {
+    return false;
+  }
+  proxyProbe = null;
+  probeSettledAt = 0;
+  ensureProxyProbe();
+  return true;
+}
+function installProbeRefresh() {
+  if (typeof window === "undefined" || probeRefreshInstalled) {
+    return;
+  }
+  probeRefreshInstalled = true;
+  window.addEventListener("focus", () => {
+    refreshStaleProbe();
+  });
+}
+installProbeRefresh();
+function hasAiCredentials() {
+  return hasOpenAiKey() || isProxyConfigured();
+}
+function isProxyConfigured() {
+  return proxyConfigured;
+}
+function isManagedProxy() {
+  return proxyManaged;
+}
+function proxyStateCode() {
+  return proxyCode;
+}
+function getProxyDefaultModel() {
+  return proxyDefaultModel;
+}
+function preferredModel() {
+  return storedModel() || getProxyDefaultModel() || SETTINGS.aiModel.default;
+}
+function siblingRoute(chatUrl, segment) {
+  let url;
+  try {
+    url = new URL(chatUrl, "http://jx.invalid");
+  } catch {
+    return chatUrl;
+  }
+  url.pathname = url.pathname.replace(/[^/]*$/, segment);
+  return /^https?:/i.test(chatUrl) ? url.href : `${url.pathname}${url.search}`;
+}
+async function fetchAvailableModels(opts = {}) {
+  const credentials = opts.credentials ?? aiConnection();
+  const key = fingerprint(credentials);
+  if (cache && cacheKey === key && !opts.force) {
+    return cache;
+  }
+  const plat = getPlatform2();
+  const chatUrl = await Promise.resolve(plat.aiChatUrl());
+  const modelsUrl = siblingRoute(chatUrl, "models");
+  const headers = {};
+  if (credentials.apiKey) {
+    headers["X-Api-Key"] = credentials.apiKey;
+  }
+  if (credentials.baseUrl) {
+    headers["X-Api-Base-URL"] = credentials.baseUrl;
+  }
+  const resp = await fetch(modelsUrl, { headers });
+  if (!resp.ok) {
+    throw new Error(`HTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  proxyConfigured = data.configured === true;
+  proxyManaged = data.managed === true;
+  proxyDefaultModel = data.defaultModel ?? "";
+  proxyCode = data.code;
+  cache = (data.models || []).map((m) => {
+    const model = { id: m.id, name: m.name || m.id };
+    if (typeof m.contextWindow === "number") {
+      model.contextWindow = m.contextWindow;
+    }
+    if (typeof m.toolSupport === "boolean") {
+      model.toolSupport = m.toolSupport;
+    }
+    return model;
+  });
+  cacheKey = key;
+  return cache;
+}
+
+export { getOpenAiKey, setOpenAiKey, hasOpenAiKey, getBaseUrl, storedModel, setModel, saveAiProvider, clearAiProvider, aiConnection, resetModelCache, cachedModels, modelToolSupport, modelContextWindow, ensureProxyProbe, hasAiCredentials, isProxyConfigured, isManagedProxy, proxyStateCode, preferredModel, fetchAvailableModels };
+
+//# debugId=F6D8D74CC11D733564756E2164756E21
+//# sourceMappingURL=studio-hhvs4sdg.js.map

package/dist/chunks/{studio-68n67094.js → studio-kcgff4r0.js}

@@ -1,11 +1,11 @@
 import {
-  project_schema_default,
-  schema_default
-} from "./studio-9r6j5ev1.js";
+  schema_default,
+  project_schema_default
+} from "./studio-d0300636.js";
 import {
-  __require,
-  __toESM
-} from "./studio-a0tswy0w.js";
+  __toESM,
+  __preload
+} from "./studio-5te5tqng.js";
 
 // src/services/jx-validate.ts
 var CORE = {
@@ -21,8 +21,8 @@ var reportedFailure = false;
 function getValidator(kind) {
   compiling[kind] ??= (async () => {
     try {
-      const { default: Ajv2020 } = await import("./2020-xp8vnwma.js").then((m)=>__toESM(m.default,1));
-      const { default: addFormats } = await import("./index-nj44jpzj.js").then((m)=>__toESM(m.default,1));
+      const { default: Ajv2020 } = await (__preload("g79n01v9"), import("./2020-g79n01v9.js").then((m)=>__toESM(m.default,1)));
+      const { default: addFormats } = await (__preload("mdmyx6s2"), import("./index-mdmyx6s2.js").then((m)=>__toESM(m.default,1)));
       const ajv = new Ajv2020({ allErrors: true, strict: false, allowUnionTypes: true });
       addFormats(ajv);
       return ajv.compile(active[kind]);
@@ -39,7 +39,7 @@ function getValidator(kind) {
 function asSchema(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0 ? value : undefined;
 }
-function applyProjectSchemas(schemas) {
+function applyProjectSchemas2(schemas) {
   const document = asSchema(schemas?.document) ?? CORE.document;
   const project = asSchema(schemas?.project) ?? CORE.project;
   const applied = document !== CORE.document || project !== CORE.project;
@@ -52,9 +52,6 @@ function applyProjectSchemas(schemas) {
   compiling.project = null;
   return applied;
 }
-function resetProjectSchemas() {
-  applyProjectSchemas(null);
-}
 var ERROR_PROPERTY_KEYS = ["unevaluatedProperty", "additionalProperty", "missingProperty"];
 function formatErrors(validate) {
   return (validate.errors || []).map((e) => {
@@ -63,21 +60,21 @@ function formatErrors(validate) {
     return `${e.instancePath || "(root)"}: ${e.message}${property}`;
   });
 }
-async function validateDoc(doc) {
+async function validateDoc2(doc) {
   const validate = await getValidator("document");
   if (!validate || validate(doc)) {
     return [];
   }
   return formatErrors(validate);
 }
-async function validateDocOrNull(doc) {
+async function validateDocOrNull2(doc) {
   const validate = await getValidator("document");
   if (!validate) {
     return null;
   }
   return validate(doc) ? [] : formatErrors(validate);
 }
-async function validateProjectConfig(config) {
+async function validateProjectConfig2(config) {
   const validate = await getValidator("project");
   if (!validate || validate(config)) {
     return [];
@@ -85,7 +82,7 @@ async function validateProjectConfig(config) {
   return formatErrors(validate);
 }
 
-export { applyProjectSchemas, resetProjectSchemas, validateDoc, validateDocOrNull, validateProjectConfig };
+export { applyProjectSchemas2, validateDoc2, validateDocOrNull2, validateProjectConfig2 };
 
-//# debugId=8C68AEE13E72EFF064756E2164756E21
-//# sourceMappingURL=studio-68n67094.js.map
+//# debugId=EC74C1A0E86832FC64756E2164756E21
+//# sourceMappingURL=studio-kcgff4r0.js.map