@jmanuelcorral/openteam 0.25.0 → 0.26.0

package/dist/index.js

@@ -1049,7 +1049,8 @@ var LocalRuntimeKindSchema = z3.enum([
   "ollama",
   "lmstudio",
   "foundry-local",
-  "lemonade"
+  "lemonade",
+  "llama-swap"
 ]);
 var LocalRuntimeSchema = z3.object({
   id: z3.string().min(1),
@@ -1069,15 +1070,25 @@ var LocalRuntimeSchema = z3.object({
     ctx.addIssue({
       code: z3.ZodIssueCode.custom,
       path: ["kind"],
-      message: `local runtime "${runtime.id}" has no resolvable kind: add "kind" ` + "(one of ollama, lmstudio, foundry-local, lemonade), since the id is " + "not itself a runtime kind."
+      message: `local runtime "${runtime.id}" has no resolvable kind: add "kind" ` + "(one of ollama, lmstudio, foundry-local, lemonade, llama-swap), " + "since the id is not itself a runtime kind."
     });
   }
+}).transform((runtime) => {
+  const resolvedKind = runtime.kind ?? runtime.id;
+  if (resolvedKind !== "llama-swap" || runtime.maxConcurrency !== undefined) {
+    return runtime;
+  }
+  return { ...runtime, maxConcurrency: 1 };
 });
 function localRuntimeKind(runtime) {
   return runtime.kind ?? runtime.id;
 }
 function effectiveMaxConcurrency(runtime) {
-  return runtime.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY;
+  if (runtime.maxConcurrency !== undefined) {
+    return runtime.maxConcurrency;
+  }
+  const kind = runtime.kind ?? (runtime.id !== undefined && LocalRuntimeKindSchema.safeParse(runtime.id).success ? runtime.id : undefined);
+  return kind === "llama-swap" ? 1 : DEFAULT_LOCAL_MAX_CONCURRENCY;
 }
 var MemoryScopeSchema = z3.enum(["project", "user"]);
 var MemoryExtractionModeSchema = z3.enum([
@@ -5746,7 +5757,7 @@ import { z as z15 } from "zod";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.25.0",
+  version: "0.26.0",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -6103,6 +6114,23 @@ var executionSetupMessages = {
 `),
   localOnlyTitle: "Local execution",
   localRequiredError: "local execution requires an enabled local runtime",
+  llamaSwap: {
+    label: "llama-swap",
+    noLoadedModels: "llama-swap has no canonical models verified as ready with no active routing profile. Keep the intended model ready through the operator's existing runtime controls, then rerun setup; manual IDs cannot bypass admission.",
+    modelNotLoaded: (model) => `llama-swap model "${model}" is not positively verified as canonical and ready without an active routing profile. No substitute was selected.`,
+    probeRequired: "llama-swap setup requires a fresh read-only residency probe before writing configuration. Manual model IDs cannot bypass this requirement.",
+    probeFailed: "llama-swap readiness could not be verified. Check the configured /v1/models catalog and origin /running and /api/profiles endpoints; authenticated runtimes are not supported.",
+    endpointMismatch: "llama-swap endpoint/provider mapping differs from the selected runtime. Reconcile the configured origin or /v1 URL and provider; no configuration was written.",
+    modelIdentityUnknown: (model) => `llama-swap model "${model}" has no usable registered physical identity. Fix its model declaration; setup will not guess an alias.`,
+    declaredLimits: "llama-swap context and output limits are operator-declared metadata, not measured per-slot capacities. Missing output metadata uses openteam's client policy default, not a guessed model cap. Unknown context remains 0 and disables automatic compaction. Tool support remains unknown without evidence.",
+    declaredLimitsTitle: "Declared llama-swap limits",
+    outputReduction: (model, previous, ceiling) => `${model}: reducing limit.output from ${previous} to ${ceiling} to respect the declared runtime ceiling. Smaller operator limits are preserved.`,
+    outputReductionTitle: "Declared output ceiling",
+    outputChanged: (model, ceiling) => `${model}: fresh runtime metadata declares an output ceiling of ${ceiling} below the prepared configuration. Rerun setup to review the updated limit; no configuration was written.`
+  },
+  residencyV2Title: "Resident runtime transport compatibility",
+  residencyV2Restriction: (providers) => `Project policies disable opencode's separate native/core V2 transport for resident-only providers: ${providers.join(", ")}. Guarded V1 provider transport remains supported; this does not ban the public SDK v2 client library. Higher-precedence policies can override project restrictions. Readiness preflight is not an atomic no-autoload guarantee.`,
+  retainedResidencyProviderUnprotected: (providerID) => `Cannot safely retain resident-only provider "${providerID}": the effective configuration must retain its matching runtime, disabled when deselected. Reconcile the runtime/provider configuration; no configuration was written.`,
   lemonadeDetectedHint: (loaded, advertised) => `detected - ${loaded} confirmed loaded of ${advertised} advertised text model(s)`,
   lemonadeNoLoadedModels: "Lemonade has no text models verified as loaded and ready. Keep the intended model active in Lemonade and rerun setup; inactive or unknown models cannot be selected or entered manually.",
   lemonadeModelNotLoaded: (model) => `Lemonade model "${model}" is not positively verified as loaded and ready. Keep that exact text model active and rerun setup; no substitute was selected and no implicit loading is allowed.`,
@@ -6117,11 +6145,11 @@ var executionSetupMessages = {
   lemonadeV2InvalidPolicies: "Cannot safely preserve experimental.policies: experimental must be an object and policies must be an array of provider.use statements with a string resource and allow/deny effect. Fix the project configuration before rerunning setup.",
   lemonadeV2Title: "Lemonade transport compatibility",
   lemonadeV2Restriction: (providers) => `Project policies disable native V2 Lemonade access for: ${providers.join(", ")}. Ordinary guarded V1 configuration remains supported; V2 is not an openteam-hook execution path. Higher-precedence or global policies can override this project restriction; it is not a server-atomic no-autoload guarantee.`,
-  lemonadeInventory: (instanceID, providerID, models) => {
+  lemonadeInventory: (instanceID, providerID, models, runtime = "Lemonade") => {
     const inventory = models.map((model) => `${model.modelID} (${model.loaded === true ? "loaded" : model.loaded === false ? "inactive" : "residency unknown"})`).join(", ");
-    return `Lemonade inventory ${instanceID} (provider ${providerID}): ${inventory || "no advertised text models"}. Only confirmed loaded text models count as ready.`;
+    return `${runtime} inventory ${instanceID} (provider ${providerID}): ${inventory || "no advertised text models"}. Only confirmed loaded text models count as ready.`;
   },
-  lemonadeAgentResidency: (agent, model, state) => `Lemonade readiness: ${agent} (${model}): ${state === "not-loaded" ? "inactive (not ready)" : "residency unknown"}; advertised inventory is not loaded readiness. Keep this exact model active and verify residency before use; requests without verified readiness are blocked.`,
+  lemonadeAgentResidency: (agent, model, state, runtime = "Lemonade") => `${runtime} readiness: ${agent} (${model}): ${state === "not-loaded" ? "inactive (not ready)" : "residency unknown"}; advertised inventory is not loaded readiness. Keep this exact model active and verify residency before use; requests without verified readiness are blocked.`,
   mixedPrimaryQuestion: "Primary coordinator model",
   mixedPrimaryLocal: (model) => `Use local thinking model ${model}`,
   mixedPrimaryFrontier: "Choose a frontier model",
@@ -6225,6 +6253,8 @@ var executionPolicyMessages = {
   primaryLocalMismatchRemedy: (sourceFile) => `      remedy: re-run \`openteam setup\` to regenerate ${sourceFile} and opencode.json from the same primary policy, then re-run \`openteam doctor\`.`
 };
 var doctorMessages = {
+  defaultRuntimeSlots: (slots) => ` · ${slots} slot(s) (default)`,
+  llamaSwapConcurrency: "    llama-swap does not report per-model slots; openteam uses the configured runtime-wide concurrency limit. No per-model capacity was inferred.",
   localModelLimits: {
     section: "  local model limits:",
     healthy: "    ✓ enabled local provider models declare valid output and context limits in opencode.json.",
@@ -6241,7 +6271,7 @@ var doctorMessages = {
     invalidInput: "invalid limit.input (expected a positive integer token count)",
     outputExceedsContext: "limit.output is greater than or equal to limit.context, so the configured context leaves no usable input window",
     outputExceedsInput: "limit.input is less than or equal to the reserved output budget, so compaction would have no usable input threshold",
-    outputRemedy: "    remedy: re-run `openteam setup` to write openteam's 8 192-token local output default, then re-run `openteam doctor`.",
+    outputRemedy: "    remedy: re-run `openteam setup` to write openteam's local output policy (at most 8 192 tokens, narrowed by declared runtime ceilings and smaller context/input budgets), then re-run `openteam doctor`.",
     unconfiguredLimitRemedy: "    remedy: the optional limit block may remain absent; to configure explicit limits, manually add a complete limit object in opencode.json with positive output and non-negative context (0 means unknown), because setup fills an absent limit block only for models the runtime currently discovers. Then re-run `openteam doctor`.",
     detectedContextRemedy: "    remedy: re-run `openteam setup` while the runtime is reachable to copy the detected usable context budget, then re-run `openteam doctor`.",
     unknownContextRemedy: "    remedy: re-run `openteam setup` to write the required context:0 sentinel; automatic compaction remains disabled until a positive context is configured.",
@@ -9953,14 +9983,12 @@ function ensureFoundryV1BaseURL(endpoint) {
   }
 }
 
-// src/local/lemonadeResidency.ts
-import { z as z19 } from "zod";
-
 // src/messages/modelResidency.ts
 var reasons = {
   unknown: "fresh residency metadata is unavailable, malformed, or ambiguous",
   inactive: "the requested model is not verified as resident and serving",
   identity: "the requested model identity can be rewritten or is ambiguous",
+  "authentication-unsupported": "authentication is required but unsupported by this integration",
   destination: "the request destination does not match its configured runtime",
   transport: "this provider execution path cannot enforce the residency guard",
   request: "this is not a supported, explicit model inference request",
@@ -9969,22 +9997,328 @@ var reasons = {
   configuration: "the residency guard configuration is invalid"
 };
 var modelResidencyMessages = {
-  blocked: (reason) => `[openteam] Lemonade model request blocked: ${reasons[reason]}.`,
-  providerDisabled: (providerID) => `[openteam] Lemonade provider "${providerID}" is disabled because its configured transport or runtime mapping cannot enforce loaded-only requests.`,
-  extractionRuntimeUnavailable: "[openteam] Memory extraction requires one enabled local runtime matching the configured extraction provider."
+  blocked: (reason, runtimeLabel = "Lemonade", detail) => `[openteam] ${runtimeLabel} model request blocked: ${reasons[reason]}${detail === undefined ? "" : ` (${detail})`}.`,
+  providerDisabled: (providerID, runtimeLabel = "Lemonade") => `[openteam] ${runtimeLabel} provider "${providerID}" is disabled because its configured transport or runtime mapping cannot enforce loaded-only requests.`,
+  extractionRuntimeUnavailable: "[openteam] Memory extraction requires one enabled local runtime matching the configured extraction provider.",
+  extractionRuntimeUnavailableFor: (runtimeLabel) => `[openteam] Memory extraction requires one enabled ${runtimeLabel} local runtime matching the configured extraction provider.`
+};
+var llamaSwapResidencyMessages = {
+  catalogModelDetail: (id, detail) => `catalog model "${id}" ${detail}`,
+  invalidCatalogField: (field) => `declares an invalid ${field}`,
+  catalogEntryMustExposeStringId: "catalog entries must expose a string id",
+  catalogModelIdsMustBeNonEmptyTrimmedStrings: "catalog model ids must be non-empty, trimmed strings",
+  expectedDataArray: (path2) => `GET ${path2} must return an object with a data array`,
+  duplicateCanonicalModelId: (modelID, path2) => `duplicate canonical model id "${modelID}" in ${path2}`,
+  httpFailure: (path2, status) => `GET ${path2} failed with HTTP ${status}`,
+  unverifiableResponse: (path2) => `GET ${path2} failed before a verifiable response`,
+  expectedProfilesArray: (path2) => `GET ${path2} must return an object with a profiles array`,
+  activeProfileRewrite: (profile) => `active profile "${profile}" can rewrite canonical model routing`,
+  invalidActiveProfileValue: (path2) => `GET ${path2} reported an invalid active profile value`,
+  expectedRunningArray: (path2) => `GET ${path2} must return an object with a running array`,
+  malformedRunningEvidence: (path2) => `GET ${path2} returned malformed model/state evidence`,
+  duplicateRunningEvidence: (path2, modelID) => `GET ${path2} returned duplicate evidence for "${modelID}"`
 };
 
-// src/local/lemonadeResidency.ts
+// src/local/residency.ts
 class ModelResidencyError extends Error {
   code;
   statusCode = 400;
   isRetryable = false;
-  constructor(code) {
-    super(modelResidencyMessages.blocked(code));
+  constructor(code, runtimeLabel = "Lemonade", detail) {
+    super(modelResidencyMessages.blocked(code, runtimeLabel, detail));
     this.code = code;
     this.name = "ModelResidencyError";
   }
 }
+async function withResidencyDeadline(operation, options) {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const runtimeLabel = options.runtimeLabel;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new ModelResidencyError("configuration", runtimeLabel);
+  }
+  const controller = new AbortController;
+  const cancel = () => controller.abort(new ModelResidencyError("cancelled", runtimeLabel));
+  if (options.signal?.aborted)
+    throw new ModelResidencyError("cancelled", runtimeLabel);
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  const schedule = options.scheduleTimeout ?? ((callback, ms) => {
+    const timer = setTimeout(callback, ms);
+    return () => clearTimeout(timer);
+  });
+  let onAbort = () => {};
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(controller.signal.reason);
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  const clearTimer = schedule(() => controller.abort(new ModelResidencyError("timeout", runtimeLabel)), timeoutMs);
+  try {
+    controller.signal.throwIfAborted();
+    return await Promise.race([operation(controller.signal), aborted]);
+  } finally {
+    clearTimer();
+    options.signal?.removeEventListener("abort", cancel);
+    controller.signal.removeEventListener("abort", onAbort);
+    controller.abort();
+  }
+}
+
+// src/local/llamaSwapResidency.ts
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function readSupportsTools2(model) {
+  const direct = readBoolean2(model, [
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "supportsToolCalling",
+    "supports_tools",
+    "supportsTools"
+  ]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  const capabilities = readCapabilityBoolean2(model.capabilities);
+  if (capabilities !== undefined) {
+    return capabilities;
+  }
+  const features = readCapabilityBoolean2(model.features);
+  if (features !== undefined) {
+    return features;
+  }
+  const labels = readCapabilityBoolean2(model.labels);
+  if (labels !== undefined) {
+    return labels;
+  }
+  return "unknown";
+}
+function readCapabilityBoolean2(value) {
+  if (Array.isArray(value)) {
+    if (value.some((entry) => typeof entry === "string" && ["tools", "tool_call", "tool-calling", "function_calling"].includes(entry))) {
+      return true;
+    }
+    return;
+  }
+  if (!isObject2(value)) {
+    return;
+  }
+  return readBoolean2(value, [
+    "tools",
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "function_calling",
+    "supportsToolCalling"
+  ]);
+}
+function readBoolean2(value, keys) {
+  for (const key of keys) {
+    if (typeof value[key] === "boolean") {
+      return value[key];
+    }
+  }
+  return;
+}
+function modelDetail(id, detail) {
+  return llamaSwapResidencyMessages.catalogModelDetail(id, detail);
+}
+function llamaSwapBaseURL(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ModelResidencyError("destination", "llama-swap");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "") {
+    throw new ModelResidencyError("destination", "llama-swap");
+  }
+  if (url.pathname === "/" || url.pathname === "") {
+    return `${url.origin}/v1`;
+  }
+  if (url.pathname === "/v1" || url.pathname === "/v1/") {
+    return `${url.origin}/v1`;
+  }
+  throw new ModelResidencyError("destination", "llama-swap");
+}
+function parseCanonicalType(entry, id) {
+  if (!isObject2(entry.meta) || !isObject2(entry.meta.llamaswap)) {
+    return;
+  }
+  const type = entry.meta.llamaswap.type;
+  if (type === undefined) {
+    return;
+  }
+  if (typeof type !== "string" || type.length === 0 || type !== type.trim()) {
+    throw new ModelResidencyError("unknown", "llama-swap", modelDetail(id, llamaSwapResidencyMessages.invalidCatalogField("meta.llamaswap.type")));
+  }
+  return type === "model" ? "model" : undefined;
+}
+function readContextCandidates(entry) {
+  const values = [
+    readPositiveSafeInteger(entry.context_length),
+    readPositiveSafeInteger(entry.context_window),
+    isObject2(entry.meta) ? readPositiveSafeInteger(entry.meta.n_ctx) : undefined
+  ];
+  return values.filter((value) => value !== undefined);
+}
+function readDeclaredMaxOutput(entry, id) {
+  if (!isObject2(entry.meta) || !isObject2(entry.meta.llamaswap)) {
+    return;
+  }
+  if (!Object.hasOwn(entry.meta.llamaswap, "max_output_tokens")) {
+    return;
+  }
+  const maxOutputTokens = readPositiveSafeInteger(entry.meta.llamaswap.max_output_tokens);
+  if (maxOutputTokens === undefined) {
+    throw new ModelResidencyError("unknown", "llama-swap", modelDetail(id, llamaSwapResidencyMessages.invalidCatalogField("meta.llamaswap.max_output_tokens")));
+  }
+  return maxOutputTokens;
+}
+function parseCatalogModel(value) {
+  if (!isObject2(value) || typeof value.id !== "string") {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.catalogEntryMustExposeStringId);
+  }
+  const id = value.id;
+  if (id.length === 0 || id !== id.trim()) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.catalogModelIdsMustBeNonEmptyTrimmedStrings);
+  }
+  if (parseCanonicalType(value, id) !== "model") {
+    return;
+  }
+  const model = {
+    modelID: id,
+    supportsTools: readSupportsTools2(value)
+  };
+  const contexts = readContextCandidates(value);
+  if (contexts.length > 0) {
+    model.contextWindow = Math.min(...contexts);
+    model.contextWindowProvenance = "declared";
+  }
+  const maxOutputTokens = readDeclaredMaxOutput(value, id);
+  if (maxOutputTokens !== undefined) {
+    model.maxOutputTokens = maxOutputTokens;
+    model.maxOutputTokensProvenance = "declared";
+  }
+  return model;
+}
+function parseCatalog(payload) {
+  if (!isObject2(payload) || !Array.isArray(payload.data)) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.expectedDataArray("/v1/models"));
+  }
+  const seen = new Set;
+  const models = [];
+  for (const entry of payload.data) {
+    const model = parseCatalogModel(entry);
+    if (model === undefined) {
+      continue;
+    }
+    if (seen.has(model.modelID)) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.duplicateCanonicalModelId(model.modelID, "/v1/models"));
+    }
+    seen.add(model.modelID);
+    models.push(model);
+  }
+  return models;
+}
+async function metadata(url, fetch, signal, headers) {
+  signal.throwIfAborted();
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal,
+      redirect: "error",
+      cache: "no-store"
+    });
+    signal.throwIfAborted();
+    if (response.status === 401 || response.status === 403) {
+      throw new ModelResidencyError("authentication-unsupported", "llama-swap");
+    }
+    if (!response.ok || response.redirected || response.url !== "" && response.url !== url) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.httpFailure(new URL(url).pathname, response.status));
+    }
+    return await response.json();
+  } catch (error) {
+    signal.throwIfAborted();
+    if (error instanceof ModelResidencyError) {
+      throw error;
+    }
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.unverifiableResponse(new URL(url).pathname));
+  }
+}
+function readProfiles(payload) {
+  if (!isObject2(payload) || !Array.isArray(payload.profiles)) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.expectedProfilesArray("/api/profiles"));
+  }
+  if (payload.active === null) {
+    return;
+  }
+  if (typeof payload.active === "string" && payload.active.length > 0 && payload.active === payload.active.trim()) {
+    throw new ModelResidencyError("identity", "llama-swap", llamaSwapResidencyMessages.activeProfileRewrite(payload.active));
+  }
+  throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.invalidActiveProfileValue("/api/profiles"));
+}
+function readRunning(payload, modelIDs) {
+  if (!isObject2(payload) || !Array.isArray(payload.running)) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.expectedRunningArray("/running"));
+  }
+  const result = new Map;
+  for (const modelID of modelIDs) {
+    result.set(modelID, { loaded: false });
+  }
+  const seen = new Set;
+  for (const entry of payload.running) {
+    if (!isObject2(entry) || typeof entry.model !== "string" || entry.model.length === 0 || entry.model !== entry.model.trim() || typeof entry.state !== "string" || entry.state.length === 0 || entry.state !== entry.state.trim()) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.malformedRunningEvidence("/running"));
+    }
+    if (seen.has(entry.model)) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.duplicateRunningEvidence("/running", entry.model));
+    }
+    seen.add(entry.model);
+    if (!modelIDs.has(entry.model)) {
+      continue;
+    }
+    result.set(entry.model, { loaded: entry.state === "ready" });
+  }
+  return result;
+}
+function requestHeaders(headers) {
+  const result = new Headers(headers);
+  result.delete("content-type");
+  result.delete("content-length");
+  result.set("accept", "application/json");
+  result.set("cache-control", "no-cache, no-store");
+  result.delete("if-none-match");
+  result.delete("if-modified-since");
+  return result;
+}
+function llamaSwapResidencyOptions(options) {
+  return { ...options, runtimeLabel: "llama-swap" };
+}
+async function readLlamaSwapCatalog(baseURL, fetch, options = {}) {
+  const base = llamaSwapBaseURL(baseURL);
+  const headers = requestHeaders(options.headers);
+  return withResidencyDeadline(async (signal) => parseCatalog(await metadata(`${base}/models`, fetch, signal, headers)), llamaSwapResidencyOptions(options));
+}
+async function readLlamaSwapResidency(baseURL, fetch, options = {}) {
+  const base = llamaSwapBaseURL(baseURL);
+  const origin = new URL(base).origin;
+  const headers = requestHeaders(options.headers);
+  return withResidencyDeadline(async (signal) => {
+    const models = await readLlamaSwapCatalog(base, fetch, {
+      ...llamaSwapResidencyOptions(options),
+      signal
+    });
+    readProfiles(await metadata(`${origin}/api/profiles`, fetch, signal, headers));
+    return readRunning(await metadata(`${origin}/running`, fetch, signal, headers), new Set(models.map((model) => model.modelID)));
+  }, llamaSwapResidencyOptions(options));
+}
+
+// src/local/lemonadeResidency.ts
+import { z as z19 } from "zod";
 var modelName = z19.string().min(1).refine((name) => name === name.trim());
 var LoadedModelSchema = z19.object({
   model_name: modelName,
@@ -10121,37 +10455,7 @@ function lemonadeBaseURL(value) {
   }
   return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
 }
-async function withResidencyDeadline(operation, options) {
-  const timeoutMs = options.timeoutMs ?? 5000;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new ModelResidencyError("configuration");
-  }
-  const controller = new AbortController;
-  const cancel = () => controller.abort(new ModelResidencyError("cancelled"));
-  if (options.signal?.aborted)
-    throw new ModelResidencyError("cancelled");
-  options.signal?.addEventListener("abort", cancel, { once: true });
-  const schedule = options.scheduleTimeout ?? ((callback, ms) => {
-    const timer = setTimeout(callback, ms);
-    return () => clearTimeout(timer);
-  });
-  let onAbort = () => {};
-  const aborted = new Promise((_, reject) => {
-    onAbort = () => reject(controller.signal.reason);
-    controller.signal.addEventListener("abort", onAbort, { once: true });
-  });
-  const clearTimer = schedule(() => controller.abort(new ModelResidencyError("timeout")), timeoutMs);
-  try {
-    controller.signal.throwIfAborted();
-    return await Promise.race([operation(controller.signal), aborted]);
-  } finally {
-    clearTimer();
-    options.signal?.removeEventListener("abort", cancel);
-    controller.signal.removeEventListener("abort", onAbort);
-    controller.abort();
-  }
-}
-async function metadata(url, fetch, signal, headers) {
+async function metadata2(url, fetch, signal, headers) {
   signal.throwIfAborted();
   let payload;
   try {
@@ -10184,8 +10488,8 @@ async function readLemonadeResidency(baseURL, fetch, options = {}) {
   headers.delete("if-none-match");
   headers.delete("if-modified-since");
   return withResidencyDeadline(async (signal) => {
-    const aliases = await metadata(`${new URL(base).origin}/internal/aliases`, fetch, signal, headers);
-    const health = await metadata(`${base}/health`, fetch, signal, headers);
+    const aliases = await metadata2(`${new URL(base).origin}/internal/aliases`, fetch, signal, headers);
+    const health = await metadata2(`${base}/health`, fetch, signal, headers);
     return parseResidency(health, aliases);
   }, options);
 }
@@ -10256,11 +10560,11 @@ async function listLemonadeModels(baseURL, fetch) {
 }
 function readNonTextModelIDs(payload) {
   const ids = new Set;
-  if (!isObject2(payload) || !Array.isArray(payload.data)) {
+  if (!isObject3(payload) || !Array.isArray(payload.data)) {
     return ids;
   }
   for (const entry of payload.data) {
-    if (!isObject2(entry) || typeof entry.id !== "string") {
+    if (!isObject3(entry) || typeof entry.id !== "string") {
       continue;
     }
     if (isNonTextModel(entry)) {
@@ -10298,7 +10602,7 @@ function readLoadedContextWindow(entry) {
 }
 function slotsFromLlamacppArgs(entry) {
   const options = entry.recipe_options;
-  if (!isObject2(options) || typeof options.llamacpp_args !== "string") {
+  if (!isObject3(options) || typeof options.llamacpp_args !== "string") {
     return;
   }
   const match = PARALLEL_ARG.exec(options.llamacpp_args);
@@ -10334,7 +10638,7 @@ function slotsFromLaunchCommand(entry) {
 }
 function contextWindowFromRecipeOptions(entry) {
   const options = entry.recipe_options;
-  if (!isObject2(options) || !hasLlamacppEvidence(entry)) {
+  if (!isObject3(options) || !hasLlamacppEvidence(entry)) {
     return;
   }
   const direct = positiveIntegerValue(options.ctx_size);
@@ -10394,7 +10698,7 @@ function hasLlamacppEvidence(entry) {
     return true;
   }
   const options = entry.recipe_options;
-  if (isObject2(options) && typeof options.llamacpp_args === "string") {
+  if (isObject3(options) && typeof options.llamacpp_args === "string") {
     return true;
   }
   return Array.isArray(entry.launch_command) && launchCommandLooksLikeLlamacpp(entry.launch_command);
@@ -10450,10 +10754,57 @@ function enrichWithLoadState(models, loaded) {
     };
   });
 }
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/local/llamaSwap.ts
+var LLAMA_SWAP_DEFAULT_BASE_URL = "http://localhost:8080/v1";
+function withLoadedState(models, residency) {
+  return models.map((model) => {
+    const loaded = residency.get(model.modelID)?.loaded;
+    return loaded === undefined ? model : { ...model, loaded };
+  });
+}
+function createLlamaSwapAdapter() {
+  const listModels = async (options) => {
+    const baseURL = llamaSwapBaseURL(options.baseURL ?? LLAMA_SWAP_DEFAULT_BASE_URL);
+    const models = await readLlamaSwapCatalog(baseURL, options.fetch);
+    try {
+      return withLoadedState(models, await readLlamaSwapResidency(baseURL, options.fetch));
+    } catch (error) {
+      if (error instanceof ModelResidencyError && (error.code === "identity" || error.code === "unknown")) {
+        return models;
+      }
+      throw error;
+    }
+  };
+  return {
+    id: "llama-swap",
+    defaultBaseURL: LLAMA_SWAP_DEFAULT_BASE_URL,
+    listModels,
+    async probe(options) {
+      const baseURL = llamaSwapBaseURL(options.baseURL ?? LLAMA_SWAP_DEFAULT_BASE_URL);
+      try {
+        return {
+          id: "llama-swap",
+          baseURL,
+          reachable: true,
+          models: await listModels({ ...options, baseURL }),
+          probedAt: options.probedAt
+        };
+      } catch (error) {
+        return unavailableSnapshot({
+          id: "llama-swap",
+          baseURL,
+          probedAt: options.probedAt,
+          error
+        });
+      }
+    }
+  };
+}
+
 // src/local/lmstudio.ts
 var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
 function createLMStudioAdapter() {
@@ -10506,6 +10857,7 @@ class RuntimeRegistry {
       lmstudio: createLMStudioAdapter(),
       "foundry-local": createFoundryLocalAdapter(),
       lemonade: createLemonadeAdapter(),
+      "llama-swap": createLlamaSwapAdapter(),
       ...options.adapters
     };
     this.clock = options.clock;
@@ -10972,7 +11324,7 @@ var TRUNCATED_REASON_SUFFIX = "…[truncated]";
 var MAX_SERIALIZED_ARRAY_ITEMS = 20;
 var MAX_SERIALIZED_OBJECT_PROPERTIES = 25;
 var MAX_SERIALIZED_DEPTH = 4;
-function isObject3(value) {
+function isObject4(value) {
   return typeof value === "object" && value !== null;
 }
 function isError(value) {
@@ -11002,7 +11354,7 @@ function stringProperty(value, key) {
 }
 function nestedMessage(value, key) {
   const container = safeGet(value, key);
-  if (!isObject3(container)) {
+  if (!isObject4(container)) {
     return;
   }
   const message = stringProperty(container, "message");
@@ -11086,7 +11438,7 @@ function errorReason(error) {
       return message;
     }
   }
-  if (isObject3(error)) {
+  if (isObject4(error)) {
     const message = stringProperty(error, "message");
     if (message !== undefined) {
       return message;
@@ -11104,7 +11456,7 @@ function errorReason(error) {
   return safeToString(error);
 }
 function isNormalizedSessionFailure(value) {
-  return isObject3(value) && safeGet(value, "kind") === "normalized-session-failure" && typeof safeGet(value, "failureClass") === "string" && typeof safeGet(value, "retryable") === "boolean";
+  return isObject4(value) && safeGet(value, "kind") === "normalized-session-failure" && typeof safeGet(value, "failureClass") === "string" && typeof safeGet(value, "retryable") === "boolean";
 }
 function createArgs(req) {
   const body = {};
@@ -11231,7 +11583,7 @@ async function confirmSessionStopped(client, sessionID, directory, deps, deadlin
       return { confirmed: false, cause: "status-error" };
     }
     const statuses = statusOutcome.value;
-    if (!isObject3(statuses)) {
+    if (!isObject4(statuses)) {
       return { confirmed: false, cause: "status-error" };
     }
     if (safeGet(statuses, "error") !== undefined) {
@@ -11381,8 +11733,11 @@ async function runSubsession(client, req, deps) {
 }
 
 // src/local/modelResidency.ts
+function runtimeRequiresModelResidency(kind) {
+  return kind === "lemonade" || kind === "llama-swap";
+}
 function hasRequiredModelResidency(kind, model) {
-  return kind !== "lemonade" || model?.loaded === true;
+  return !runtimeRequiresModelResidency(kind) || model?.loaded === true;
 }
 
 // src/plugin/availability.ts
@@ -11391,9 +11746,9 @@ function modelKey2(model) {
 }
 function availabilityMetadata({
   apiModelID: _apiModelID,
-  ...metadata2
+  ...metadata3
 }) {
-  return metadata2;
+  return metadata3;
 }
 function compareAvailableModels(left, right) {
   const kindOrder = Number(left.kind === "frontier") - Number(right.kind === "frontier");
@@ -11413,7 +11768,7 @@ function isConfiguredLocalModel(config, model) {
   return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === model.providerID);
 }
 function requiresModelResidency(config, model) {
-  return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === model.providerID && !hasRequiredModelResidency(localRuntimeKind(runtime), undefined));
+  return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === model.providerID && runtimeRequiresModelResidency(localRuntimeKind(runtime)));
 }
 function configuredFrontierProviderIDs(config) {
   const providerIDs = new Set([config.baseline.hardDefault.providerID]);
@@ -12039,6 +12394,7 @@ var PROVIDER_LABELS = {
   ollama: "Ollama",
   lmstudio: "LM Studio",
   lemonade: "Lemonade Server",
+  "llama-swap": executionSetupMessages.llamaSwap.label,
   "foundry-local": "Foundry Local"
 };
 function providerLabel(providerID) {
@@ -12260,7 +12616,8 @@ var KNOWN_LOCAL_PROVIDER_IDS = new Set([
   "ollama",
   "lmstudio",
   "foundry-local",
-  "lemonade"
+  "lemonade",
+  "llama-swap"
 ]);
 var KNOWN_FRONTIER_PROVIDER_IDS = new Set([
   "github-copilot",
@@ -12606,7 +12963,7 @@ function runtimeLine(snapshot, runtime) {
   const mark = snapshot.reachable ? "✓" : "✗";
   const detail = snapshot.reachable ? `${snapshot.models.length} model(s)` : snapshot.error ?? "unreachable";
   const declared = runtime?.maxConcurrency;
-  const slots = declared === undefined ? ` · ${DEFAULT_LOCAL_MAX_CONCURRENCY} slot(s) (default)` : ` · ${declared} slot(s) (declared)`;
+  const slots = declared === undefined ? doctorMessages.defaultRuntimeSlots(effectiveMaxConcurrency(runtime ?? {})) : ` · ${declared} slot(s) (declared)`;
   return `  ${mark} ${snapshot.id.padEnd(14)} ${snapshot.baseURL || "(no baseURL)"} — ${detail}${slots}`;
 }
 function runtimeModelSlotsLine(runtime, snapshot) {
@@ -12618,6 +12975,8 @@ function runtimeModelSlotsLine(runtime, snapshot) {
   if (runtime === undefined || snapshot === undefined || !snapshot.reachable || snapshot.models.length === 0) {
     return [];
   }
+  if (localRuntimeKind(runtime) === "llama-swap")
+    return [doctorMessages.llamaSwapConcurrency];
   const reported = snapshot.models.flatMap((model) => model.slots === undefined ? [] : [`${model.modelID} ${model.slots} slot(s)`]);
   if (reported.length > 0) {
     return [
@@ -13021,7 +13380,7 @@ function renderDoctor(input) {
       continue;
     }
     const runtime = enabledRuntimes.find((r) => r.id === snapshot.id);
-    const cap = runtime?.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY;
+    const cap = effectiveMaxConcurrency(runtime ?? {});
     lines.push(`  ⚠ ${snapshot.id} is reached over the network: its ${cap}-slot cap is enforced per openteam process, so`, "    two processes at once (an opencode session plus 'openteam console') can together exceed it.");
   }
   lines.push(`  telemetry: ${input.telemetryPath} — ${input.telemetryRecords} record(s)`);
@@ -13633,6 +13992,38 @@ function missingGeneratedStateRules(gitignore) {
   const present = new Set(activeGitignoreRules(gitignore));
   return OPENCODE_GITIGNORE_GENERATED_STATE_RULES.filter((rule) => !present.has(rule));
 }
+var KNOWN_RUNTIMES = [
+  {
+    id: "ollama",
+    label: "Ollama",
+    defaultBaseURL: "http://localhost:11434/v1",
+    fallbackModelID: "qwen3:8b"
+  },
+  {
+    id: "lmstudio",
+    label: "LM Studio",
+    defaultBaseURL: "http://localhost:1234/v1",
+    fallbackModelID: "qwen2.5-coder"
+  },
+  {
+    id: "lemonade",
+    label: "Lemonade Server",
+    defaultBaseURL: LEMONADE_DEFAULT_BASE_URL,
+    fallbackModelID: "Qwen3-Coder-30B-A3B-Instruct-GGUF"
+  },
+  {
+    id: "llama-swap",
+    label: executionSetupMessages.llamaSwap.label,
+    defaultBaseURL: LLAMA_SWAP_DEFAULT_BASE_URL,
+    fallbackModelID: ""
+  },
+  {
+    id: "foundry-local",
+    label: "Foundry Local",
+    fallbackModelID: "Phi-4-mini-instruct",
+    dynamicPort: true
+  }
+];
 
 // src/commands/purge.ts
 var PURGE_CATEGORY_IDS = [
@@ -14661,7 +15052,7 @@ function liveModelsFromSnapshots(snapshots, config) {
     map.set(runtime.defaultModel.providerID, {
       reachable: snapshot.reachable,
       modelIDs: new Set(snapshot.models.filter((model) => hasRequiredModelResidency(kind, model)).map((model) => model.modelID)),
-      ...kind === "lemonade" ? {
+      ...runtimeRequiresModelResidency(kind) ? {
         residency: new Map(snapshot.models.map((model) => [model.modelID, model.loaded]))
       } : {}
     });
@@ -14991,9 +15382,9 @@ async function runCli(argv, deps) {
       const inventoryNotes = [];
       const readySnapshots = snapshots.map((snapshot) => {
         const runtime = config.local.runtimes.find((runtime2) => runtime2.id === snapshot.id);
-        if (runtime === undefined || localRuntimeKind(runtime) !== "lemonade")
+        if (runtime === undefined || !runtimeRequiresModelResidency(localRuntimeKind(runtime)))
           return snapshot;
-        inventoryNotes.push(executionSetupMessages.lemonadeInventory(runtime.id, runtime.defaultModel.providerID, snapshot.models));
+        inventoryNotes.push(executionSetupMessages.lemonadeInventory(runtime.id, runtime.defaultModel.providerID, snapshot.models, localRuntimeKind(runtime) === "llama-swap" ? "llama-swap" : "Lemonade"));
         return {
           ...snapshot,
           models: snapshot.models.filter((model) => hasRequiredModelResidency(localRuntimeKind(runtime), model))
@@ -15004,7 +15395,7 @@ async function runCli(argv, deps) {
         if (agent.model === undefined || live !== "not-loaded" && live !== "residency-unknown")
           return [];
         return [
-          executionSetupMessages.lemonadeAgentResidency(agent.name, `${agent.model.providerID}/${agent.model.modelID}`, live)
+          executionSetupMessages.lemonadeAgentResidency(agent.name, `${agent.model.providerID}/${agent.model.modelID}`, live, config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === agent.model?.providerID && localRuntimeKind(runtime) === "llama-swap") ? "llama-swap" : "Lemonade")
         ];
       });
       return {
@@ -17234,6 +17625,84 @@ function createLemonadeGuardedFetch(options) {
   });
 }
 
+// src/local/llamaSwapRequestGuard.ts
+var inferencePaths2 = new Set([
+  "/chat/completions",
+  "/completions",
+  "/embeddings",
+  "/responses"
+]);
+async function validatedModelID(payload, modelIDs) {
+  if (typeof payload !== "object" || payload === null || !("model" in payload) || typeof payload.model !== "string" || payload.model.length === 0 || payload.model !== payload.model.trim()) {
+    throw new ModelResidencyError("request", "llama-swap");
+  }
+  if (modelIDs === undefined) {
+    return payload.model;
+  }
+  const ids = typeof modelIDs === "function" ? await modelIDs() : modelIDs;
+  if (ids.has(payload.model)) {
+    return payload.model;
+  }
+  throw new ModelResidencyError("identity", "llama-swap");
+}
+function createLlamaSwapGuardedFetch(options) {
+  const base = llamaSwapBaseURL(options.baseURL);
+  const upstream = options.fetch;
+  const healthFetch = options.healthFetch ?? upstream;
+  return Object.assign(async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    if (url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !request.url.startsWith(`${base}/`)) {
+      throw new ModelResidencyError("destination", "llama-swap");
+    }
+    const path4 = request.url.slice(base.length);
+    const metadataOnly = request.method === "GET" && /^\/models(?:\/[^/]+)?$/.test(path4);
+    if (!metadataOnly && (request.method !== "POST" || !inferencePaths2.has(path4))) {
+      throw new ModelResidencyError("request", "llama-swap");
+    }
+    if (!metadataOnly) {
+      await withResidencyDeadline(async (signal) => {
+        signal.throwIfAborted();
+        let payload;
+        try {
+          payload = await request.clone().json();
+        } catch {
+          signal.throwIfAborted();
+          throw new ModelResidencyError("request", "llama-swap");
+        }
+        signal.throwIfAborted();
+        const model = await validatedModelID(payload, options.modelIDs);
+        const residency = await readLlamaSwapResidency(base, healthFetch, {
+          ...options,
+          signal,
+          headers: request.headers
+        });
+        signal.throwIfAborted();
+        if (!residency.has(model)) {
+          throw new ModelResidencyError("identity", "llama-swap");
+        }
+        if (residency.get(model)?.loaded !== true) {
+          throw new ModelResidencyError("inactive", "llama-swap");
+        }
+      }, { ...options, signal: request.signal, runtimeLabel: "llama-swap" });
+    }
+    if (request.signal.aborted) {
+      throw new ModelResidencyError("cancelled", "llama-swap");
+    }
+    const {
+      body: _body,
+      headers: _headers,
+      method: _method,
+      signal: _signal,
+      redirect: _redirect,
+      ...transportOptions
+    } = init ?? {};
+    return upstream(request, { ...transportOptions, redirect: "error" });
+  }, {
+    preconnect: (...args) => upstream.preconnect?.(...args)
+  });
+}
+
 // src/plugin/modelResidency.ts
 function isFetch(value) {
   return typeof value === "function";
@@ -17273,20 +17742,29 @@ function providerRoutes(provider) {
     npm: model?.provider?.npm ?? provider.npm
   }));
 }
-function wireID(key, model) {
+function wireID(key, model, runtimeLabel = "Lemonade") {
   const id = model?.id ?? key;
   if (id.length === 0 || id !== id.trim())
-    throw new ModelResidencyError("identity");
+    throw new ModelResidencyError("identity", runtimeLabel);
   return id;
 }
 function nativeEligibleID(id) {
   return id === "openai" || id === "anthropic" || id.startsWith("opencode");
 }
+function normalizedBase(kind, baseURL) {
+  return kind === "llama-swap" ? llamaSwapBaseURL(baseURL) : lemonadeBaseURL(baseURL);
+}
+function runtimeBase(runtime) {
+  return runtime.baseURL ?? (localRuntimeKind(runtime) === "llama-swap" ? LLAMA_SWAP_DEFAULT_BASE_URL : LEMONADE_DEFAULT_BASE_URL);
+}
+function residencyRuntimeLabel(config, providerID) {
+  return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === providerID && localRuntimeKind(runtime) === "llama-swap") ? "llama-swap" : "Lemonade";
+}
 function configuredRuntime(config, providerID) {
   const runtimes = config.local.runtimes.filter((runtime2) => runtime2.defaultModel.providerID === providerID);
   const runtime = runtimes[0];
   if (runtimes.length !== 1 || runtime === undefined || !runtime.enabled) {
-    throw new ModelResidencyError("destination");
+    throw new ModelResidencyError("destination", residencyRuntimeLabel(config, providerID));
   }
   return runtime;
 }
@@ -17295,8 +17773,9 @@ function createModelResidencyGuard(config, options) {
   const blocked = new Set;
   let hostConfig;
   const readEnv = options.readEnv ?? ((name) => process.env[name]);
-  const lemonadeRuntimes = () => config.local.runtimes.filter((runtime) => localRuntimeKind(runtime) === "lemonade");
-  const protects = (providerID, baseURL) => lemonadeRuntimes().some((runtime) => {
+  const failure = (code, providerID) => new ModelResidencyError(code, residencyRuntimeLabel(config, providerID));
+  const residentRuntimes = () => config.local.runtimes.filter((runtime) => runtimeRequiresModelResidency(localRuntimeKind(runtime)));
+  const protects = (providerID, baseURL) => residentRuntimes().some((runtime) => {
     if (runtime.defaultModel.providerID === providerID)
       return true;
     if (baseURL === undefined)
@@ -17304,13 +17783,13 @@ function createModelResidencyGuard(config, options) {
     const binding = endpointBinding(baseURL, readEnv);
     if (binding.ambiguous)
       return true;
-    return binding.origin !== undefined && binding.origin === origin(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
+    return binding.origin !== undefined && binding.origin === origin(runtimeBase(runtime));
   });
   const resolvedWireID = (model, declaredID) => {
     const id = options.resolveApiModelID === undefined ? declaredID : options.resolveApiModelID(model);
     if (id === undefined)
-      throw new ModelResidencyError("identity");
-    return wireID(id, undefined);
+      throw failure("identity", model.providerID);
+    return wireID(id, undefined, residencyRuntimeLabel(config, model.providerID));
   };
   const configHook = async (host) => {
     hostConfig = host;
@@ -17330,21 +17809,22 @@ function createModelResidencyGuard(config, options) {
         ...new Set([...host.disabled_providers ?? [], providerID])
       ];
       const reject = Object.assign(async () => {
-        throw new ModelResidencyError("transport");
+        throw failure("transport", providerID);
       }, { preconnect: () => {} });
       provider.options = { ...provider.options, fetch: reject };
       try {
         const runtime = configuredRuntime(config, providerID);
-        const baseURL = lemonadeBaseURL(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
-        if (localRuntimeKind(runtime) !== "lemonade" || routes.some((route) => route.baseURL === undefined || lemonadeBaseURL(route.baseURL) !== baseURL))
-          throw new ModelResidencyError("destination");
+        const kind = localRuntimeKind(runtime);
+        const baseURL = normalizedBase(kind, runtimeBase(runtime));
+        if (!runtimeRequiresModelResidency(kind) || routes.some((route) => route.baseURL === undefined || normalizedBase(kind, route.baseURL) !== baseURL))
+          throw failure("destination", providerID);
         if (routes.some((route) => route.npm !== "@ai-sdk/openai-compatible") || nativeEligibleID(providerID) || !isFetch(originalFetch))
-          throw new ModelResidencyError("transport");
+          throw failure("transport", providerID);
         const modelKeys = new Map;
         for (const [key, model] of Object.entries(provider.models ?? {})) {
-          if (model.options?.fetch !== undefined || model.options?.baseURL !== undefined && (typeof model.options.baseURL !== "string" || lemonadeBaseURL(model.options.baseURL) !== baseURL))
-            throw new ModelResidencyError("transport");
-          modelKeys.set(key, wireID(key, model));
+          if (model.options?.fetch !== undefined || model.options?.baseURL !== undefined && (typeof model.options.baseURL !== "string" || normalizedBase(kind, model.options.baseURL) !== baseURL))
+            throw failure("transport", providerID);
+          modelKeys.set(key, wireID(key, model, residencyRuntimeLabel(config, providerID)));
         }
         if (!modelKeys.has(runtime.defaultModel.modelID))
           modelKeys.set(runtime.defaultModel.modelID, undefined);
@@ -17353,11 +17833,12 @@ function createModelResidencyGuard(config, options) {
           for (const [modelID2, declaredID] of modelKeys) {
             const id = options.resolveApiModelID === undefined ? declaredID : options.resolveApiModelID({ providerID, modelID: modelID2 });
             if (id !== undefined)
-              ids.add(wireID(id, undefined));
+              ids.add(wireID(id, undefined, residencyRuntimeLabel(config, providerID)));
           }
           return ids;
         };
-        const fetch = createLemonadeGuardedFetch({
+        const guardFetch = kind === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch;
+        const fetch = guardFetch({
           ...options,
           baseURL,
           modelIDs: async () => {
@@ -17368,7 +17849,10 @@ function createModelResidencyGuard(config, options) {
           healthFetch: options.fetch
         });
         provider.options.fetch = fetch;
+        if (kind === "llama-swap")
+          provider.options.baseURL = baseURL;
         guarded.set(providerID, {
+          kind,
           baseURL,
           fetch,
           originalFetch,
@@ -17382,7 +17866,7 @@ function createModelResidencyGuard(config, options) {
       } catch (error) {
         if (!(error instanceof ModelResidencyError))
           throw error;
-        (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(providerID));
+        (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(providerID, residencyRuntimeLabel(config, providerID)));
       }
     }
   };
@@ -17392,48 +17876,52 @@ function createModelResidencyGuard(config, options) {
       return;
     const provider = guarded.get(input.model.providerID);
     if (provider === undefined || blocked.has(input.model.providerID) || input.provider.options.fetch !== provider.fetch || input.model.api.npm !== "@ai-sdk/openai-compatible" || nativeEligibleID(input.model.providerID))
-      throw new ModelResidencyError("transport");
-    if (lemonadeBaseURL(base) !== provider.baseURL) {
-      throw new ModelResidencyError("destination");
+      throw failure("transport", input.model.providerID);
+    if (normalizedBase(provider.kind, base) !== provider.baseURL) {
+      throw failure("destination", input.model.providerID);
     }
+    if (input.model.options.fetch !== undefined || input.model.options.baseURL !== undefined && (typeof input.model.options.baseURL !== "string" || normalizedBase(provider.kind, input.model.options.baseURL) !== provider.baseURL))
+      throw failure("transport", input.model.providerID);
     const id = resolvedWireID({ providerID: input.model.providerID, modelID: input.model.id }, provider.modelKeys.get(input.model.id));
     if (id !== input.model.api.id)
-      throw new ModelResidencyError("identity");
+      throw failure("identity", input.model.providerID);
     if (!provider.modelKeys.has(input.model.id))
       provider.modelKeys.set(input.model.id, undefined);
   };
   const localTarget = (model) => {
     const runtime = configuredRuntime(config, model.providerID);
+    const kind = localRuntimeKind(runtime);
+    const needsResidency = runtimeRequiresModelResidency(kind);
     if (hostConfig?.disabled_providers?.includes(model.providerID)) {
-      throw new ModelResidencyError("transport");
+      throw failure("transport", model.providerID);
     }
     if (runtime.baseURL === undefined)
-      throw new ModelResidencyError("destination");
+      throw failure("destination", model.providerID);
     const provider = hostConfig?.provider?.[model.providerID];
     const entry = Object.hasOwn(provider?.models ?? {}, model.modelID) ? provider?.models?.[model.modelID] : undefined;
     const configuredURL = provider === undefined ? undefined : providerBase(provider, entry);
-    if (configuredURL !== undefined && new URL(configuredURL).href.replace(/\/$/, "") !== new URL(runtime.baseURL).href.replace(/\/$/, "")) {
-      throw new ModelResidencyError("destination");
+    if (configuredURL !== undefined && (needsResidency ? normalizedBase(kind, configuredURL) !== normalizedBase(kind, runtime.baseURL) : new URL(configuredURL).href.replace(/\/$/, "") !== new URL(runtime.baseURL).href.replace(/\/$/, ""))) {
+      throw failure("destination", model.providerID);
     }
-    const modelID2 = resolvedWireID(model, entry === undefined && localRuntimeKind(runtime) === "lemonade" ? undefined : wireID(model.modelID, entry));
+    const modelID2 = resolvedWireID(model, entry === undefined && needsResidency ? undefined : wireID(model.modelID, entry, residencyRuntimeLabel(config, model.providerID)));
     let fetch = options.fetch;
-    if (localRuntimeKind(runtime) === "lemonade") {
+    if (needsResidency) {
       const installed = guarded.get(model.providerID);
       if (installed === undefined || blocked.has(model.providerID)) {
-        throw new ModelResidencyError("transport");
+        throw failure("transport", model.providerID);
       }
-      if (installed.baseURL !== lemonadeBaseURL(runtime.baseURL)) {
-        throw new ModelResidencyError("destination");
+      if (installed.baseURL !== normalizedBase(kind, runtime.baseURL)) {
+        throw failure("destination", model.providerID);
       }
       if (!installed.modelKeys.has(model.modelID))
         installed.modelKeys.set(model.modelID, undefined);
       if (!installed.modelIDs().has(modelID2))
-        throw new ModelResidencyError("identity");
+        throw failure("identity", model.providerID);
       fetch = installed.fetch;
     }
     const configuredHeaders = z25.record(z25.string(), z25.string()).safeParse(provider?.options?.headers ?? {});
     if (!configuredHeaders.success)
-      throw new ModelResidencyError("configuration");
+      throw failure("configuration", model.providerID);
     const headers = new Headers(configuredHeaders.data);
     if (typeof provider?.options?.apiKey === "string" && !headers.has("authorization")) {
       headers.set("authorization", `Bearer ${provider.options.apiKey}`);
@@ -17442,7 +17930,7 @@ function createModelResidencyGuard(config, options) {
       headers.set(name, value);
     const upstream = fetch;
     return {
-      baseURL: runtime.baseURL,
+      baseURL: needsResidency ? normalizedBase(kind, runtime.baseURL) : runtime.baseURL,
       modelID: modelID2,
       fetch: [...headers].length === 0 ? fetch : Object.assign(async (input, init) => {
         const request = new Request(input, init);
@@ -18565,7 +19053,7 @@ var memoryToolMessages = {
   scribeOnly: (actualRoleID) => `openteam memory: refused — memory records may only be written by the "scribe" role, not "${actualRoleID}".`,
   disabled: "openteam memory: semantic memory is disabled; nothing was recorded.",
   frontierDomainRefusal: 'openteam memory: refused — memory extraction requires local model execution, but router.executionMode is "frontier". Set router.executionMode to "local" or "mixed" and configure a reachable local runtime.',
-  localRuntimeUnavailable: "openteam memory: memory extraction requires a local runtime that is reachable and will not fall back to a frontier provider. Configure Ollama, LM Studio, Lemonade, or Foundry Local and run `openteam doctor`.",
+  localRuntimeUnavailable: "openteam memory: memory extraction requires a local runtime that is reachable and will not fall back to a frontier provider. Configure Ollama, LM Studio, Lemonade, llama-swap, or Foundry Local and run `openteam doctor`.",
   localRuntimeBaseURLMissing: "openteam memory: refused — no local runtime with a base URL is configured and enabled; memory extraction is local-only.",
   extractionFailure: (reason) => `openteam memory: extraction failed; nothing was recorded (${reason}).`,
   noRecords: "openteam memory: no records were extracted; nothing was recorded.",
@@ -18635,14 +19123,16 @@ function createMemoryTool(deps) {
         if (runtime?.baseURL === undefined || runtime.baseURL.length === 0) {
           return memoryToolMessages.localRuntimeBaseURLMissing;
         }
-        const baseURL = runtime.baseURL;
+        const kind = localRuntimeKind(runtime);
+        const baseURL = kind === "llama-swap" ? llamaSwapBaseURL(runtime.baseURL) : runtime.baseURL;
         const model = configuredModel ?? runtime.defaultModel;
         const selectedRuntime = runtime;
         const deadline = {
           ...deps.residencyOptions,
+          ...kind === "llama-swap" ? { runtimeLabel: "llama-swap" } : {},
           ...signal === undefined ? {} : { signal }
         };
-        const reachable = localRuntimeKind(runtime) === "lemonade" ? await withResidencyDeadline((signal2) => deps.localRuntimeReachable(selectedRuntime, signal2), deadline) : await deps.localRuntimeReachable(runtime);
+        const reachable = runtimeRequiresModelResidency(kind) ? await withResidencyDeadline((signal2) => deps.localRuntimeReachable(selectedRuntime, signal2), deadline) : await deps.localRuntimeReachable(runtime);
         throwIfAborted();
         if (!reachable)
           return memoryToolMessages.localRuntimeUnavailable;
@@ -18650,7 +19140,7 @@ function createMemoryTool(deps) {
         const target = resolveTarget ? await withResidencyDeadline(async () => resolveTarget(model), deadline) : {
           baseURL,
           modelID: model.modelID,
-          fetch: localRuntimeKind(runtime) === "lemonade" ? createLemonadeGuardedFetch({
+          fetch: runtimeRequiresModelResidency(kind) ? (kind === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch)({
             baseURL,
             fetch: deps.fetch,
             modelIDs: new Set([model.modelID]),
@@ -21569,6 +22059,13 @@ function createLocalEmbedder(request, deps) {
   return (texts) => embedTexts({ ...request, texts }, deps);
 }
 
+// src/messages/memoryRuntime.ts
+var memoryRuntimeMessages = {
+  providerUnavailable: "[openteam] Semantic memory requires exactly one enabled local runtime matching the configured embeddings provider. No embedding request was sent.",
+  unavailable: "[openteam] Semantic memory initialization failed; recall and memory injection are unavailable.",
+  rejectedLines: (count) => `[openteam] memory log rejected ${count} line(s); semantic memory may be incomplete.`
+};
+
 // src/storage/index/bunSqlite.ts
 async function createBunSqliteDatabase(path4) {
   const mod = await import("bun:sqlite");
@@ -21652,7 +22149,14 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   if (options.requireInjectionEnabled === true && !semantic.injection.enabled) {
     return;
   }
-  const runtime = config.local.runtimes.find((rt) => rt.enabled && rt.baseURL !== undefined);
+  const warn = deps.warn ?? console.warn;
+  const configuredModel = semantic.embeddings.model;
+  const candidates = configuredModel == null ? config.local.runtimes.filter((rt) => rt.enabled && rt.baseURL !== undefined) : config.local.runtimes.filter((rt) => rt.defaultModel.providerID === configuredModel.providerID);
+  const runtime = candidates[0];
+  if (configuredModel != null && (candidates.length !== 1 || runtime?.enabled !== true)) {
+    warn(memoryRuntimeMessages.providerUnavailable);
+    return;
+  }
   if (runtime?.baseURL === undefined) {
     return;
   }
@@ -21661,15 +22165,22 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   const makeEmbedder = deps.createEmbedder ?? createLocalEmbedder;
   const fetchImpl = deps.fetch ?? globalThis.fetch;
   const now = deps.now ?? (() => Date.now());
-  const warn = deps.warn ?? console.warn;
+  const kind = localRuntimeKind(runtime);
   try {
+    const baseURL = kind === "llama-swap" ? llamaSwapBaseURL(runtime.baseURL) : runtime.baseURL;
+    const guardedFetch = runtimeRequiresModelResidency(kind) ? (kind === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch)({
+      baseURL,
+      fetch: fetchImpl,
+      healthFetch: fetchImpl,
+      modelIDs: new Set([modelID2])
+    }) : fetchImpl;
     const db = await openDatabase(semantic.indexPath);
     const index = createMemoryIndex(db, warn);
     const rebuildResult = await rebuildMemoryIndexFromStorage(index, semantic.logPath, { storage: deps.storage });
     if (rebuildResult.rejectedLines > 0) {
-      warn(`[openteam] memory log rejected ${rebuildResult.rejectedLines} line(s); semantic memory may be incomplete.`);
+      warn(memoryRuntimeMessages.rejectedLines(rebuildResult.rejectedLines));
     }
-    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID: modelID2 }, { fetch: fetchImpl });
+    const embedder = makeEmbedder({ baseURL, modelID: modelID2 }, { fetch: guardedFetch });
     await ensureMemoryEmbeddings({ index, embedder, model: modelID2, warn });
     return {
       index,
@@ -21679,6 +22190,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
       semantic
     };
   } catch {
+    warn(memoryRuntimeMessages.unavailable);
     return;
   }
 }
@@ -22049,8 +22561,8 @@ function readRun(runDir, runID) {
   if (metadataText === undefined || eventsText === undefined) {
     throw new LifecycleFsError("corrupt");
   }
-  const metadata2 = parseJson(metadataText, parseLifecycleRunMetadata);
-  if (metadata2.runID !== runID) {
+  const metadata3 = parseJson(metadataText, parseLifecycleRunMetadata);
+  if (metadata3.runID !== runID) {
     throw new LifecycleFsError("corrupt");
   }
   let decoded;
@@ -22065,10 +22577,10 @@ function readRun(runDir, runID) {
     }
   }
   const first = decoded.events[0];
-  if (first === undefined || first.type !== "run.started" || first.source !== metadata2.source || first.executionAuthority !== metadata2.executionAuthority || first.root.operationID !== metadata2.root.operationID || first.root.taskID !== metadata2.root.taskID) {
+  if (first === undefined || first.type !== "run.started" || first.source !== metadata3.source || first.executionAuthority !== metadata3.executionAuthority || first.root.operationID !== metadata3.root.operationID || first.root.taskID !== metadata3.root.taskID) {
     throw new LifecycleFsError("corrupt");
   }
-  return { metadata: metadata2, decoded };
+  return { metadata: metadata3, decoded };
 }
 function terminalOutcome(events) {
   const last = events.at(-1);
@@ -22146,7 +22658,7 @@ var createFsLifecycleJournal = (options) => {
         mkdirSync3(stagingPath);
         const writerToken = issueWriterToken();
         const eventAt = now();
-        const metadata2 = parseLifecycleRunMetadata({
+        const metadata3 = parseLifecycleRunMetadata({
           ...parsedInput,
           version: 1,
           createdAt: eventAt
@@ -22162,7 +22674,7 @@ var createFsLifecycleJournal = (options) => {
           executionAuthority: parsedInput.executionAuthority,
           root: parsedInput.root
         });
-        writeDurable2(join15(stagingPath, METADATA_FILE), `${JSON.stringify(metadata2)}
+        writeDurable2(join15(stagingPath, METADATA_FILE), `${JSON.stringify(metadata3)}
 `);
         writeDurable2(join15(stagingPath, EVENTS_FILE), encodeLifecycleJournal([event]));
         writeDurable2(join15(stagingPath, OWNER_FILE2), `${JSON.stringify(lease)}
@@ -22178,7 +22690,7 @@ var createFsLifecycleJournal = (options) => {
         stagingPath = undefined;
         return ok({
           handle: { runID, writerToken },
-          metadata: metadata2,
+          metadata: metadata3,
           event,
           lease,
           head: 1
@@ -23299,6 +23811,20 @@ var server = async (ctx, rawOptions) => {
     storage,
     now,
     localRuntimeReachable: async (runtime, signal) => {
+      if (localRuntimeKind(runtime) === "llama-swap") {
+        if (ctx.client.config?.providers !== undefined)
+          await ensureAvailability();
+        signal?.throwIfAborted();
+        const target = modelResidency.localTarget(resolveMemorySemantic(config).extraction.model ?? runtime.defaultModel);
+        const residency = await readLlamaSwapResidency(target.baseURL, globalThis.fetch, {
+          ...signal === undefined ? {} : { signal }
+        });
+        if (!residency.has(target.modelID))
+          throw new ModelResidencyError("identity", "llama-swap");
+        if (residency.get(target.modelID)?.loaded !== true)
+          throw new ModelResidencyError("inactive", "llama-swap");
+        return true;
+      }
       if (localRuntimeKind(runtime) === "lemonade") {
         if (ctx.client.config?.providers !== undefined)
           await ensureAvailability();