@cortexkit/opencode-magic-context 0.38.1 → 0.39.0

package/src/shared/model-resolution.ts

@@ -0,0 +1,227 @@
+export type ModelHarness = "opencode" | "pi";
+
+export interface ResolvedModelEntry {
+    /** Canonical provider/model reference used for identity and model selection. */
+    model: string;
+    /** OpenCode variant or Pi thinking level, selected for the active entry only. */
+    qualifier?: string;
+}
+
+export type ModelInput = string | ResolvedModelEntry;
+
+type ConfigRecord = Record<string, unknown>;
+
+function asRecord(value: unknown): ConfigRecord | undefined {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? (value as ConfigRecord)
+        : undefined;
+}
+
+function readString(value: unknown): string | undefined {
+    if (typeof value !== "string") return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function hasOwn(record: ConfigRecord, key: string): boolean {
+    return Object.hasOwn(record, key);
+}
+
+/**
+ * Collapses the string and object spellings of a harness model entry into the
+ * same model identity. Qualifiers stay separate because they alter an attempt,
+ * not the configured model identity.
+ */
+export function normalizeModelEntry(
+    entry: unknown,
+    harness: ModelHarness,
+): ResolvedModelEntry | undefined {
+    if (typeof entry === "string") {
+        const model = readString(entry);
+        return model ? { model } : undefined;
+    }
+
+    const objectEntry = asRecord(entry);
+    if (!objectEntry) return undefined;
+    const model = readString(objectEntry.model);
+    if (!model) return undefined;
+
+    const qualifier = readString(
+        objectEntry[harness === "opencode" ? "variant" : "thinking_level"],
+    );
+    return qualifier ? { model, qualifier } : { model };
+}
+
+function isValidModelReference(entry: ResolvedModelEntry): boolean {
+    const slash = entry.model.indexOf("/");
+    return slash > 0 && slash < entry.model.length - 1;
+}
+
+function sameAttempt(a: ResolvedModelEntry, b: ResolvedModelEntry): boolean {
+    return a.model === b.model && a.qualifier === b.qualifier;
+}
+
+/**
+ * Resolves a configured fallback list in declaration order. Attempts are
+ * deduplicated by model plus qualifier: the same model with distinct
+ * qualifiers remains two intentional attempts.
+ */
+export function resolveFallbackEntries(
+    value: unknown,
+    harness: ModelHarness,
+): ResolvedModelEntry[] {
+    const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+    const resolved: ResolvedModelEntry[] = [];
+    for (const value of values) {
+        const entry = normalizeModelEntry(value, harness);
+        if (!entry || !isValidModelReference(entry)) continue;
+        if (resolved.some((candidate) => sameAttempt(candidate, entry))) continue;
+        resolved.push(entry);
+    }
+    return resolved;
+}
+
+function resolvePrimaryEntry(args: {
+    entry: unknown;
+    defaultQualifier: unknown;
+    harness: ModelHarness;
+}): ResolvedModelEntry | undefined {
+    const entry = normalizeModelEntry(args.entry, args.harness);
+    if (!entry) return undefined;
+    const qualifier = entry.qualifier ?? readString(args.defaultQualifier);
+    return qualifier ? { ...entry, qualifier } : entry;
+}
+
+export interface ResolvedHistorianModel {
+    primary?: ResolvedModelEntry;
+    fallbacks: ResolvedModelEntry[];
+}
+
+/**
+ * Resolve historian model attempts from exactly one harness block. Flat keys
+ * and the other harness are deliberately never consulted after cutover.
+ */
+export function resolveHistorianModel(
+    config: unknown,
+    harness: ModelHarness,
+): ResolvedHistorianModel {
+    const historian = asRecord(asRecord(config)?.historian);
+    const block = asRecord(historian?.[harness]);
+    if (!block) return { fallbacks: [] };
+
+    return {
+        primary: resolvePrimaryEntry({
+            entry: block.model,
+            defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+            harness,
+        }),
+        fallbacks: resolveFallbackEntries(block.fallback_models, harness),
+    };
+}
+
+export interface ResolvedDreamerTaskModel {
+    primary?: ResolvedModelEntry;
+    fallbacks: ResolvedModelEntry[];
+    schedule?: string;
+    timeoutMinutes?: number;
+    promotionThreshold?: number;
+}
+
+/**
+ * Resolve a dreamer task from one harness subtree. Model selection is task →
+ * harness default, except compress-cues inserts its harness-independent mural
+ * string between those two rungs. Scheduling remains at dreamer.tasks.<task>.
+ */
+export function resolveDreamerTaskModel(args: {
+    config: unknown;
+    harness: ModelHarness;
+    task: string;
+    muralModel?: unknown;
+}): ResolvedDreamerTaskModel {
+    const dreamer = asRecord(asRecord(args.config)?.dreamer);
+    const harnessBlock = asRecord(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"];
+    // A mural string borrows the harness default's qualifier whether that
+    // qualifier is written beside `model` or inside the default entry object.
+    const harnessQualifier =
+        harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ??
+        normalizeModelEntry(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,
+            // mural.model is a plain string, so its qualifier is always the
+            // executing harness default rather than a task-local default.
+            defaultQualifier: usesMuralModel
+                ? harnessQualifier
+                : (taskQualifier ?? harnessQualifier),
+            harness: args.harness,
+        }),
+        fallbacks: resolveFallbackEntries(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,
+    };
+}
+
+/**
+ * Keep non-model agent settings at their original level while replacing only
+ * OpenCode's model-resolution fields with the executing harness's primary.
+ */
+export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, unknown> {
+    const source = asRecord(agent);
+    if (!source) return {};
+    const {
+        model: _model,
+        fallback_models: _fallbackModels,
+        variant: _variant,
+        thinking_level: _thinking,
+        opencode,
+        pi,
+        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 } : {}),
+    };
+}

package/src/shared/model-suggestion-retry.test.ts

@@ -56,6 +56,33 @@ describe("promptSyncWithModelSuggestionRetry", () => {
         expect(prompt).toHaveBeenCalledTimes(1);
     });
 
+    test("each active fallback sends only its own variant", async () => {
+        const prompt = mock(async () => {
+            if (prompt.mock.calls.length <= 2) throw new Error("attempt failed");
+            return {};
+        });
+        const client = createClient(prompt);
+
+        await promptSyncWithModelSuggestionRetry(
+            client,
+            {
+                path: { id: "ses-test" },
+                body: { model: { providerID: "anthropic", modelID: "primary" }, variant: "high" },
+            },
+            {
+                fallbackModels: [{ model: "anthropic/fallback", qualifier: "low" }, "google/bare"],
+            },
+        );
+
+        expect((prompt.mock.calls[1]?.[0] as PromptCall).body).toMatchObject({
+            model: { providerID: "anthropic", modelID: "fallback" },
+            variant: "low",
+        });
+        const bareFallbackBody = (prompt.mock.calls[2]?.[0] as PromptCall).body;
+        expect(bareFallbackBody.model).toEqual({ providerID: "google", modelID: "bare" });
+        expect(bareFallbackBody.variant).toBeUndefined();
+    });
+
     test("primary fails, fallback[0] succeeds", async () => {
         const prompt = mock(async () => {
             if (prompt.mock.calls.length === 1) throw new Error("primary failed");

package/src/shared/model-suggestion-retry.ts

@@ -2,7 +2,8 @@ import type { createOpencodeClient } from "@opencode-ai/sdk";
 
 import { detectOverflow } from "../features/magic-context/overflow-detection";
 import { log } from "./logger";
-import { parseProviderModel } from "./resolve-fallbacks";
+import type { ModelInput } from "./model-resolution";
+import { parseProviderModel, toModelEntry } from "./resolve-fallbacks";
 
 type Client = ReturnType<typeof createOpencodeClient>;
 
@@ -13,6 +14,8 @@ const ABORT_CALL_TIMEOUT_MS = 3000;
 
 export type PromptBody = {
     model?: { providerID: string; modelID: string };
+    /** OpenCode variant; Pi's facade also uses it as the active thinking level. */
+    variant?: string;
     [key: string]: unknown;
 };
 
@@ -64,7 +67,7 @@ export interface PromptRetryOptions {
      *   - On all-failed, the LAST error is thrown (matches legacy behavior when
      *     `fallbackModels` is empty).
      */
-    fallbackModels?: readonly string[];
+    fallbackModels?: readonly ModelInput[];
     /**
      * Identifier for structured logging (e.g. "dreamer:consolidate",
      * "historian", "compressor", "sidekick"). Helps correlate fallback
@@ -394,16 +397,19 @@ export async function promptSyncWithModelSuggestionRetry(
 
     // Iterate fallbacks.
     for (let i = 0; i < fallbacks.length; i += 1) {
-        const parsed = parseProviderModel(fallbacks[i]);
+        const fallback = toModelEntry(fallbacks[i]);
+        const parsed = fallback ? parseProviderModel(fallback.model) : null;
         if (!parsed) {
-            log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+            log(`[${callContext}] skipping invalid fallback spec: ${String(fallbacks[i])}`);
             continue;
         }
 
         const label = `${parsed.providerID}/${parsed.modelID}`;
+        const { variant: _primaryVariant, ...bodyWithoutPrimaryVariant } = baseBody;
         const attemptArgs = copyPromptArgs(baseArgs, {
-            ...baseBody,
+            ...bodyWithoutPrimaryVariant,
             model: parsed,
+            ...(fallback?.qualifier ? { variant: fallback.qualifier } : {}),
         });
 
         try {
@@ -429,7 +435,7 @@ export async function promptSyncWithModelSuggestionRetry(
     // caller's report (e.g. /ctx-dream tasks_json) still surfaces a real
     // diagnostic.
     log(
-        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; last error: ${shortErr(lastError)}`,
+        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; last error: ${shortErr(lastError)}`,
     );
     throw lastError ?? new Error("All fallback models failed");
 }
@@ -515,16 +521,19 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     }
 
     for (let i = 0; i < fallbacks.length; i += 1) {
-        const parsed = parseProviderModel(fallbacks[i]);
+        const fallback = toModelEntry(fallbacks[i]);
+        const parsed = fallback ? parseProviderModel(fallback.model) : null;
         if (!parsed) {
-            log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+            log(`[${callContext}] skipping invalid fallback spec: ${String(fallbacks[i])}`);
             continue;
         }
 
         const label = `${parsed.providerID}/${parsed.modelID}`;
+        const { variant: _primaryVariant, ...bodyWithoutPrimaryVariant } = baseBody;
         const attemptArgs = copyPromptArgs(baseArgs, {
-            ...baseBody,
+            ...bodyWithoutPrimaryVariant,
             model: parsed,
+            ...(fallback?.qualifier ? { variant: fallback.qualifier } : {}),
         });
         const attempt: PromptAttemptInfo = {
             label,
@@ -563,7 +572,7 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     }
 
     log(
-        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
+        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
     );
     throw firstError ?? lastError ?? new Error("All fallback models failed validation");
 }

package/src/shared/resolve-fallbacks.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
+import { modelBodyField, parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
 
 describe("resolveFallbackChain", () => {
     // Policy: user-config-only. There is NO builtin provider-agnostic chain —
@@ -62,6 +62,18 @@ describe("resolveFallbackChain", () => {
     });
 });
 
+describe("modelBodyField", () => {
+    test("sends the active entry variant and leaves a bare entry unqualified", () => {
+        expect(modelBodyField({ model: "anthropic/claude-sonnet", qualifier: "high" })).toEqual({
+            model: { providerID: "anthropic", modelID: "claude-sonnet" },
+            variant: "high",
+        });
+        expect(modelBodyField("google/gemini-flash")).toEqual({
+            model: { providerID: "google", modelID: "gemini-flash" },
+        });
+    });
+});
+
 describe("parseProviderModel", () => {
     test("parses standard provider/model", () => {
         expect(parseProviderModel("anthropic/claude-sonnet-4-6")).toEqual({

package/src/shared/resolve-fallbacks.ts

@@ -1,3 +1,5 @@
+import type { ModelInput, ResolvedModelEntry } from "./model-resolution";
+
 /**
  * Resolve the fallback model list to attempt for a hidden-agent (historian /
  * dreamer / sidekick) call when its configured primary fails.
@@ -71,10 +73,23 @@ export function parseProviderModel(spec: string): { providerID: string; modelID:
  * unparseable (the session falls back to its default model). Spread into a
  * `client.session.prompt` body.
  */
-export function modelBodyField(spec: string | undefined): {
+export function modelBodyField(spec: ModelInput | undefined): {
     model?: { providerID: string; modelID: string };
+    variant?: string;
 } {
-    if (!spec) return {};
-    const parsed = parseProviderModel(spec);
-    return parsed ? { model: parsed } : {};
+    const entry = toModelEntry(spec);
+    if (!entry) return {};
+    const parsed = parseProviderModel(entry.model);
+    return parsed
+        ? { model: parsed, ...(entry.qualifier ? { variant: entry.qualifier } : {}) }
+        : {};
+}
+
+/** Convert legacy string call sites and resolved entries into one active attempt shape. */
+export function toModelEntry(spec: ModelInput | undefined): ResolvedModelEntry | undefined {
+    if (typeof spec === "string") {
+        const model = spec.trim();
+        return model ? { model } : undefined;
+    }
+    return spec;
 }

package/src/shared/status-detail-text.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test";
+import type { StatusDetail } from "./rpc-types";
+import { formatStatusDetailMarkdown } from "./status-detail-text";
+
+const STATUS_FIXTURE: StatusDetail = {
+    sessionId: "ses_status",
+    usagePercentage: 75,
+    inputTokens: 96_000,
+    contextLimit: 128_000,
+    systemPromptTokens: 4_000,
+    compartmentCount: 12,
+    memoryCount: 8,
+    memoryBlockCount: 3,
+    pendingOpsCount: 2,
+    historianRunning: true,
+    compartmentInProgress: true,
+    sessionNoteCount: 1,
+    readySmartNoteCount: 2,
+    cacheTtl: "5m",
+    lastTransformError: null,
+    lastDreamerRunAt: null,
+    projectIdentity: "/repo",
+    compartmentTokens: 22_000,
+    factTokens: 0,
+    memoryTokens: 1_200,
+    docsTokens: 500,
+    profileTokens: 100,
+    conversationTokens: 62_000,
+    toolCallTokens: 3_000,
+    toolDefinitionTokens: 3_200,
+    executeThreshold: 65,
+    executeThresholdClamped: false,
+    boundaryPresent: true,
+    coverageOrdinal: 12,
+    newWorkTokens: 1_000,
+    totalInputTokens: 96_000,
+    recompProgress: null,
+    tagCounter: 5,
+    activeTags: 4,
+    droppedTags: 1,
+    totalTags: 5,
+    activeBytes: 2_048,
+    lastResponseTime: 1,
+    lastNudgeTokens: 80_000,
+    pendingOps: [],
+    cacheTtlMs: 300_000,
+    cacheRemainingMs: 42_000,
+    cacheExpired: false,
+    cacheNeverExpires: false,
+    executeThresholdMode: "percentage",
+    protectedTagCount: 20,
+    historyBudgetPercentage: 0.15,
+    historyBlockTokens: 22_000,
+    compressionBudget: 12_480,
+    compressionUsage: "176%",
+    toastDurationMs: 5_000,
+    loggerDiagnostics: {
+        swallowedWriteCount: 0,
+        lastErrorMessage: null,
+        lastErrorTime: null,
+    },
+    storage_versions: {
+        context_db_schema_version: 79,
+        plugin_supported_version: 79,
+    },
+};
+
+describe("formatStatusDetailMarkdown", () => {
+    test("renders the fixed TUI status payload as compact markdown", () => {
+        expect(formatStatusDetailMarkdown(STATUS_FIXTURE)).toBe(`## Magic Context Status
+
+- **Mode:** Magic Context compaction
+- **Usage:** 75.0% (96,000 / 128,000 usable tokens)
+- **Cache lane:** live (42s remaining); TTL 5m
+- **Historian:** running; boundary present; coverage 12
+- **Memory:** 8 active; 3 injected
+- **Tags:** 4 active, 1 dropped; 2 pending drops
+- **Execute threshold:** 65.0%`);
+    });
+});

package/src/shared/status-detail-text.ts

@@ -0,0 +1,56 @@
+import type { StatusDetail } from "./rpc-types";
+
+function formatCount(value: number): string {
+    return Math.round(value).toLocaleString();
+}
+
+function formatCacheLane(detail: StatusDetail): string {
+    if (detail.cacheNeverExpires) return `never expires; TTL ${detail.cacheTtl}`;
+    if (detail.lastResponseTime <= 0) return `waiting for first response; TTL ${detail.cacheTtl}`;
+    if (detail.cacheExpired) return `expired; TTL ${detail.cacheTtl}`;
+    return `live (${Math.round(detail.cacheRemainingMs / 1000)}s remaining); TTL ${detail.cacheTtl}`;
+}
+
+/** Render the same StatusDetail payload that powers the TUI dialog for chat-only clients. */
+export function formatStatusDetailMarkdown(detail: StatusDetail): string {
+    const usableLimit =
+        detail.contextLimit > 0
+            ? `${formatCount(detail.contextLimit)} usable tokens`
+            : "? usable tokens";
+    const historianState = detail.historianRunning ? "running" : "idle";
+    const historianDetails = [
+        detail.boundaryPresent === undefined
+            ? undefined
+            : `boundary ${detail.boundaryPresent ? "present" : "absent"}`,
+        detail.coverageOrdinal === undefined
+            ? undefined
+            : `coverage ${detail.coverageOrdinal === null ? "none" : detail.coverageOrdinal}`,
+    ].filter((value): value is string => value !== undefined);
+    const mode =
+        detail.compaction_enabled === false
+            ? "native compaction (Magic Context history compaction disabled)"
+            : "Magic Context compaction";
+
+    const lines = [
+        "## Magic Context Status",
+        "",
+        `- **Mode:** ${mode}`,
+        `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount(detail.inputTokens)} / ${usableLimit})`,
+        `- **Cache lane:** ${formatCacheLane(detail)}`,
+        `- **Historian:** ${[historianState, ...historianDetails].join("; ")}`,
+        `- **Memory:** ${formatCount(detail.memoryCount)} active; ${formatCount(detail.memoryBlockCount)} injected`,
+        `- **Tags:** ${formatCount(detail.activeTags)} active, ${formatCount(detail.droppedTags)} dropped; ${formatCount(detail.pendingOpsCount)} pending drops`,
+        `- **Execute threshold:** ${detail.executeThreshold.toFixed(1)}%${detail.executeThresholdClamped ? " (clamped)" : ""}`,
+    ];
+
+    if (detail.recompProgress?.phase === "recomp") {
+        lines.push(
+            `- **${detail.recompProgress.kind === "embed" ? "Embed" : "Historian"} progress:** ${formatCount(detail.recompProgress.processedMessages)} / ${formatCount(detail.recompProgress.totalMessages)}`,
+        );
+    }
+    if (detail.lastTransformError) {
+        lines.push(`- **Last transform error:** ${detail.lastTransformError}`);
+    }
+
+    return lines.join("\n");
+}

package/src/shared/subagent-runner.ts

@@ -29,6 +29,8 @@
  * the runner contract is purely additive on the OpenCode side.
  */
 
+import type { ModelInput } from "./model-resolution";
+
 /**
  * Configuration for one subagent invocation.
  *
@@ -63,7 +65,7 @@ export interface SubagentRunOptions {
     systemPrompt: string;
     userMessage: string;
     model?: string | undefined;
-    fallbackModels?: readonly string[];
+    fallbackModels?: readonly ModelInput[];
     timeoutMs?: number | undefined;
     cwd?: string | undefined;
     signal?: AbortSignal | undefined;

package/dist/index-td9depx5.js

@@ -1,46 +0,0 @@
-// src/shared/resolve-fallbacks.ts
-function resolveFallbackChain(userFallbacks) {
-  const userList = normalizeUserFallbacks(userFallbacks);
-  return dedupe(userList.filter(isValidModelSpec));
-}
-function normalizeUserFallbacks(userFallbacks) {
-  if (!userFallbacks)
-    return [];
-  if (typeof userFallbacks === "string") {
-    const trimmed = userFallbacks.trim();
-    return trimmed ? [trimmed] : [];
-  }
-  return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function isValidModelSpec(spec) {
-  const slash = spec.indexOf("/");
-  return slash > 0 && slash < spec.length - 1;
-}
-function dedupe(list) {
-  const seen = new Set;
-  const out = [];
-  for (const item of list) {
-    if (seen.has(item))
-      continue;
-    seen.add(item);
-    out.push(item);
-  }
-  return out;
-}
-function parseProviderModel(spec) {
-  const slash = spec.indexOf("/");
-  if (slash < 1 || slash >= spec.length - 1)
-    return null;
-  return {
-    providerID: spec.slice(0, slash).trim(),
-    modelID: spec.slice(slash + 1).trim()
-  };
-}
-function modelBodyField(spec) {
-  if (!spec)
-    return {};
-  const parsed = parseProviderModel(spec);
-  return parsed ? { model: parsed } : {};
-}
-
-export { resolveFallbackChain, parseProviderModel, modelBodyField };

package/dist/resolve-fallbacks-qf0ekmz9.js

@@ -1,11 +0,0 @@
-import {
-  modelBodyField,
-  parseProviderModel,
-  resolveFallbackChain
-} from "./index-td9depx5.js";
-import"./index-1yh8g550.js";
-export {
-  modelBodyField,
-  parseProviderModel,
-  resolveFallbackChain
-};