@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/dist/v2/server-sfpzqvdz.js

@@ -0,0 +1,137 @@
+// src/shared/model-resolution.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function readString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function hasOwn(record, key) {
+  return Object.hasOwn(record, key);
+}
+function resolveHarnessBlock(container, harness) {
+  const selected = harness === "omp" ? container?.omp ?? container?.pi : container?.[harness];
+  return asRecord(selected);
+}
+function normalizeModelEntry2(entry, harness) {
+  if (typeof entry === "string") {
+    const model = readString(entry);
+    return model ? { model } : undefined;
+  }
+  const objectEntry = asRecord(entry);
+  if (!objectEntry)
+    return;
+  const model = readString(objectEntry.model);
+  if (!model)
+    return;
+  const qualifier = readString(objectEntry[harness === "opencode" ? "variant" : "thinking_level"]);
+  return qualifier ? { model, qualifier } : { model };
+}
+function isValidModelReference(entry) {
+  const slash = entry.model.indexOf("/");
+  return slash > 0 && slash < entry.model.length - 1;
+}
+function sameAttempt(a, b) {
+  return a.model === b.model && a.qualifier === b.qualifier;
+}
+function resolveFallbackEntries2(value, harness) {
+  const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+  const resolved = [];
+  for (const value of values) {
+    const entry = normalizeModelEntry2(value, harness);
+    if (!entry || !isValidModelReference(entry))
+      continue;
+    if (resolved.some((candidate) => sameAttempt(candidate, entry)))
+      continue;
+    resolved.push(entry);
+  }
+  return resolved;
+}
+function resolvePrimaryEntry(args) {
+  const entry = normalizeModelEntry2(args.entry, args.harness);
+  if (!entry)
+    return;
+  const qualifier = entry.qualifier ?? readString(args.defaultQualifier);
+  return qualifier ? { ...entry, qualifier } : entry;
+}
+function resolveHistorianModel2(config, harness) {
+  const historian = asRecord(asRecord(config)?.historian);
+  const block = resolveHarnessBlock(historian, harness);
+  if (!block)
+    return { fallbacks: [] };
+  return {
+    primary: resolvePrimaryEntry({
+      entry: block.model,
+      defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+      harness
+    }),
+    fallbacks: resolveFallbackEntries2(block.fallback_models, harness)
+  };
+}
+function resolveDreamerTaskModel2(args) {
+  const dreamer = asRecord(asRecord(args.config)?.dreamer);
+  const harnessBlock = resolveHarnessBlock(dreamer, args.harness);
+  const taskBlock = asRecord(asRecord(harnessBlock?.tasks)?.[args.task]);
+  const schedulingTask = asRecord(asRecord(dreamer?.tasks)?.[args.task]);
+  if (!harnessBlock) {
+    return {
+      fallbacks: [],
+      schedule: readString(schedulingTask?.schedule),
+      timeoutMinutes: typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
+      promotionThreshold: typeof schedulingTask?.promotion_threshold === "number" ? schedulingTask.promotion_threshold : undefined
+    };
+  }
+  const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
+  const harnessQualifier = harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ?? normalizeModelEntry2(harnessBlock.model, args.harness)?.qualifier;
+  const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
+  const usesMuralModel = !taskHasModel && args.task === "compress-cues" && Boolean(readString(args.muralModel));
+  const primarySource = taskHasModel ? taskBlock?.model : usesMuralModel ? args.muralModel : harnessBlock.model;
+  const fallbackSource = taskBlock !== undefined && hasOwn(taskBlock, "fallback_models") ? taskBlock.fallback_models : harnessBlock.fallback_models;
+  return {
+    primary: resolvePrimaryEntry({
+      entry: primarySource,
+      defaultQualifier: usesMuralModel ? harnessQualifier : taskQualifier ?? harnessQualifier,
+      harness: args.harness
+    }),
+    fallbacks: resolveFallbackEntries2(fallbackSource, args.harness),
+    schedule: readString(schedulingTask?.schedule),
+    timeoutMinutes: typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
+    promotionThreshold: typeof schedulingTask?.promotion_threshold === "number" ? schedulingTask.promotion_threshold : undefined
+  };
+}
+function resolveOpenCodeAgentOverrides2(agent) {
+  const source = asRecord(agent);
+  if (!source)
+    return {};
+  const {
+    model: _model,
+    fallback_models: _fallbackModels,
+    variant: _variant,
+    thinking_level: _thinking,
+    opencode,
+    pi,
+    omp,
+    tasks,
+    ...rest
+  } = source;
+  const primary = resolvePrimaryEntry({
+    entry: asRecord(opencode)?.model,
+    defaultQualifier: asRecord(opencode)?.variant,
+    harness: "opencode"
+  });
+  return {
+    ...rest,
+    ...primary ? { model: primary.model } : {},
+    ...primary?.qualifier ? { variant: primary.qualifier } : {}
+  };
+}
+function resolveHistorianAgentOverrides2(agent) {
+  return {
+    maxTokens: 32000,
+    ...resolveOpenCodeAgentOverrides2(agent)
+  };
+}
+
+export { normalizeModelEntry2, resolveFallbackEntries2, resolveHistorianModel2, resolveDreamerTaskModel2, resolveOpenCodeAgentOverrides2, resolveHistorianAgentOverrides2 };

package/dist/v2/server-syahy8j8.js

@@ -0,0 +1,50 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toESM, __commonJS, __export, __require };