stagent 0.10.0 → 0.11.1

package/src/lib/agents/runtime/catalog.ts

@@ -21,6 +21,51 @@ export interface RuntimeCapabilities {
   authHealthCheck: boolean;
 }
 
+/**
+ * LLM-surface features that affect what the model sees and which tools/skills
+ * Stagent exposes to it. Distinct from RuntimeCapabilities above, which is
+ * adapter-plumbing concerns (can the adapter resume/cancel/etc.).
+ *
+ * Values reflect post-Phase-1 capability (what the runtime SDK *can* do),
+ * not current engagement (what `engine.ts` currently activates). Downstream
+ * features read this bag to decide rendering, filtering, and dispatch.
+ */
+export interface RuntimeFeatures {
+  /** SDK provides a native skill-invocation tool (e.g. Claude SDK `Skill` tool). */
+  hasNativeSkills: boolean;
+  /** SDK loads skill metadata first, full SKILL.md on demand. */
+  hasProgressiveDisclosure: boolean;
+  /** Read/Grep/Glob/Edit/Write available as LLM tools. */
+  hasFilesystemTools: boolean;
+  /** Bash tool available (Stagent gates via permission bridge). */
+  hasBash: boolean;
+  /** TodoWrite tool available. */
+  hasTodoWrite: boolean;
+  /** Runtime supports delegating to sub-agents (e.g. Task tool). */
+  hasSubagentDelegation: boolean;
+  /** Runtime loads filesystem hooks (pre/post tool-use shell scripts). */
+  hasHooks: boolean;
+  /** Which project-level instructions file the runtime auto-loads, if any. */
+  autoLoadsInstructions: "CLAUDE.md" | "AGENTS.md" | null;
+  /**
+   * Runtime has no native skill support — Stagent must inject SKILL.md content
+   * into the system prompt to expose skills to the LLM.
+   */
+  stagentInjectsSkills: boolean;
+  /**
+   * Runtime supports composing multiple active skills in one conversation.
+   * When false, only one skill may be active at a time (Ollama: context
+   * budget too tight). When true, `activate_skill mode:"add"` is allowed
+   * up to `maxActiveSkills`.
+   */
+  supportsSkillComposition: boolean;
+  /**
+   * Maximum number of skills that may be simultaneously active. Enforced
+   * by the activate_skill tool. Ignored when supportsSkillComposition=false.
+   */
+  maxActiveSkills: number;
+}
+
 export interface RuntimeModelConfig {
   /** Default model ID for this runtime */
   default: string;
@@ -34,6 +79,7 @@ export interface RuntimeCatalogEntry {
   description: string;
   providerId: "anthropic" | "openai" | "ollama";
   capabilities: RuntimeCapabilities;
+  features: RuntimeFeatures;
   /** Model catalog — default and supported model IDs for this runtime */
   models: RuntimeModelConfig;
 }
@@ -54,6 +100,19 @@ const RUNTIME_CATALOG: Record<AgentRuntimeId, RuntimeCatalogEntry> = {
       profileAssist: true,
       authHealthCheck: true,
     },
+    features: {
+      hasNativeSkills: true,
+      hasProgressiveDisclosure: true,
+      hasFilesystemTools: true,
+      hasBash: true,
+      hasTodoWrite: true,
+      hasSubagentDelegation: false, // Stagent task primitives replace SDK Task tool
+      hasHooks: false, // excluded per Q2
+      autoLoadsInstructions: "CLAUDE.md",
+      stagentInjectsSkills: false,
+      supportsSkillComposition: true,
+      maxActiveSkills: 3,
+    },
     models: {
       default: "sonnet",
       supported: ["haiku", "sonnet", "opus"],
@@ -74,6 +133,19 @@ const RUNTIME_CATALOG: Record<AgentRuntimeId, RuntimeCatalogEntry> = {
       profileAssist: false,
       authHealthCheck: true,
     },
+    features: {
+      hasNativeSkills: true,
+      hasProgressiveDisclosure: true,
+      hasFilesystemTools: true,
+      hasBash: true,
+      hasTodoWrite: true,
+      hasSubagentDelegation: false,
+      hasHooks: false,
+      autoLoadsInstructions: "AGENTS.md",
+      stagentInjectsSkills: false,
+      supportsSkillComposition: true,
+      maxActiveSkills: 3,
+    },
     models: {
       default: "gpt-5.4",
       supported: ["gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex"],
@@ -94,6 +166,21 @@ const RUNTIME_CATALOG: Record<AgentRuntimeId, RuntimeCatalogEntry> = {
       profileAssist: true,
       authHealthCheck: true,
     },
+    features: {
+      // Direct Messages API — no SDK-native skill machinery.
+      // Revisit when chat-claude-sdk-skills designs direct-API skill injection.
+      hasNativeSkills: false,
+      hasProgressiveDisclosure: false,
+      hasFilesystemTools: false,
+      hasBash: false,
+      hasTodoWrite: false,
+      hasSubagentDelegation: false,
+      hasHooks: false,
+      autoLoadsInstructions: null,
+      stagentInjectsSkills: false,
+      supportsSkillComposition: true,
+      maxActiveSkills: 3,
+    },
     models: {
       default: "claude-sonnet-4-20250514",
       supported: ["claude-haiku-4-5-20251001", "claude-sonnet-4-20250514", "claude-opus-4-20250514"],
@@ -114,6 +201,21 @@ const RUNTIME_CATALOG: Record<AgentRuntimeId, RuntimeCatalogEntry> = {
       profileAssist: false,
       authHealthCheck: true,
     },
+    features: {
+      // Direct Responses API — no SDK-native skill machinery.
+      // Revisit when chat-claude-sdk-skills designs direct-API skill injection.
+      hasNativeSkills: false,
+      hasProgressiveDisclosure: false,
+      hasFilesystemTools: false,
+      hasBash: false,
+      hasTodoWrite: false,
+      hasSubagentDelegation: false,
+      hasHooks: false,
+      autoLoadsInstructions: null,
+      stagentInjectsSkills: false,
+      supportsSkillComposition: true,
+      maxActiveSkills: 3,
+    },
     models: {
       default: "gpt-4.1",
       supported: ["gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano"],
@@ -134,6 +236,19 @@ const RUNTIME_CATALOG: Record<AgentRuntimeId, RuntimeCatalogEntry> = {
       profileAssist: false,
       authHealthCheck: true,
     },
+    features: {
+      hasNativeSkills: false,
+      hasProgressiveDisclosure: false,
+      hasFilesystemTools: false,
+      hasBash: false,
+      hasTodoWrite: false, // Stagent MCP exposes todo tools separately
+      hasSubagentDelegation: false,
+      hasHooks: false,
+      autoLoadsInstructions: null,
+      stagentInjectsSkills: true,
+      supportsSkillComposition: false,
+      maxActiveSkills: 1,
+    },
     models: {
       default: "llama3",
       supported: [],  // Dynamic — populated from Ollama API at runtime
@@ -157,6 +272,12 @@ export function getRuntimeCapabilities(
   return getRuntimeCatalogEntry(runtimeId).capabilities;
 }
 
+export function getRuntimeFeatures(
+  runtimeId: AgentRuntimeId = DEFAULT_AGENT_RUNTIME
+): RuntimeFeatures {
+  return getRuntimeCatalogEntry(runtimeId).features;
+}
+
 export function resolveAgentRuntime(runtimeId?: string | null): AgentRuntimeId {
   if (!runtimeId) return DEFAULT_AGENT_RUNTIME;
   if (isAgentRuntimeId(runtimeId)) return runtimeId;

package/src/lib/agents/runtime/claude-sdk.ts

@@ -1,3 +1,35 @@
+// ─── Claude Agent SDK options shared by chat and task runtimes ──────
+//
+// Chat (src/lib/chat/engine.ts) and task (src/lib/agents/claude-agent.ts)
+// both construct query() options for the `claude-code` runtime. These
+// constants are the single source of truth so the two code paths cannot
+// drift — a drift that would manifest as "skills work in chat but vanish
+// in tasks on the same project." See features/task-runtime-skill-parity.md
+// and features/chat-claude-sdk-skills.md.
+
+export const CLAUDE_SDK_SETTING_SOURCES = ["user", "project"] as const;
+
+export const CLAUDE_SDK_ALLOWED_TOOLS = [
+  "Skill",
+  "Read",
+  "Grep",
+  "Glob",
+  "Edit",
+  "Write",
+  "Bash",
+  "TodoWrite",
+] as const;
+
+/**
+ * Filesystem tools safe to auto-allow without a permission prompt.
+ * Mirrors the existing browser/exa read-only auto-allow pattern.
+ */
+export const CLAUDE_SDK_READ_ONLY_FS_TOOLS = new Set<string>([
+  "Read",
+  "Grep",
+  "Glob",
+]);
+
 /**
  * Build the environment for the Claude Agent SDK subprocess.
  *

package/src/lib/agents/runtime/execution-target.ts

@@ -0,0 +1,456 @@
+import { getProfile } from "@/lib/agents/profiles/registry";
+import { profileSupportsRuntime } from "@/lib/agents/profiles/compatibility";
+import { suggestRuntime } from "@/lib/agents/router";
+import {
+  DEFAULT_AGENT_RUNTIME,
+  getRuntimeCatalogEntry,
+  getRuntimeFeatures,
+  resolveAgentRuntime,
+  type AgentRuntimeId,
+} from "./catalog";
+import { testRuntimeConnection } from "./index";
+import { getRoutingPreference } from "@/lib/settings/routing";
+import { getRuntimeSetupStates, listConfiguredRuntimeIds } from "@/lib/settings/runtime-setup";
+import { DEFAULT_CHAT_MODEL, getRuntimeForModel } from "@/lib/chat/types";
+
+const FILESYSTEM_TOOL_NAMES = new Set([
+  "Read",
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "Grep",
+  "Glob",
+]);
+
+const CHAT_MODEL_FALLBACKS: Record<string, string[]> = {
+  haiku: ["gpt-5.4-mini", "gpt-5.3-codex", "gpt-5.4"],
+  sonnet: ["gpt-5.3-codex", "gpt-5.4", "gpt-5.4-mini"],
+  opus: ["gpt-5.4", "gpt-5.3-codex", "gpt-5.4-mini"],
+  "gpt-5.4-mini": ["haiku", "sonnet", "opus"],
+  "gpt-5.3-codex": ["sonnet", "haiku", "opus"],
+  "gpt-5.4": ["opus", "sonnet", "haiku"],
+};
+
+export class RuntimeUnavailableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RuntimeUnavailableError";
+  }
+}
+
+export class RequestedModelUnavailableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RequestedModelUnavailableError";
+  }
+}
+
+export class NoCompatibleRuntimeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "NoCompatibleRuntimeError";
+  }
+}
+
+export interface ResolvedExecutionTarget {
+  requestedRuntimeId: AgentRuntimeId | null;
+  effectiveRuntimeId: AgentRuntimeId;
+  requestedModelId: string | null;
+  effectiveModelId: string | null;
+  fallbackApplied: boolean;
+  fallbackReason: string | null;
+}
+
+type RuntimeRequirements = {
+  requiresBash: boolean;
+  requiresFilesystem: boolean;
+};
+
+type RuntimeAvailability = {
+  available: boolean;
+  reason: string | null;
+};
+
+function unique<T>(values: T[]): T[] {
+  return Array.from(new Set(values));
+}
+
+function getRuntimeLabel(runtimeId: AgentRuntimeId): string {
+  return getRuntimeCatalogEntry(runtimeId).label;
+}
+
+function detectRuntimeRequirements(profileId?: string | null): RuntimeRequirements {
+  const profile = profileId ? getProfile(profileId) : undefined;
+  const allowedTools = profile?.allowedTools ?? [];
+
+  const requiresBash = allowedTools.some(
+    (tool) => tool === "Bash" || tool.startsWith("Bash(")
+  );
+  const requiresFilesystem =
+    requiresBash ||
+    allowedTools.some((tool) => FILESYSTEM_TOOL_NAMES.has(tool));
+
+  return { requiresBash, requiresFilesystem };
+}
+
+function runtimeMeetsRequirements(
+  runtimeId: AgentRuntimeId,
+  requirements: RuntimeRequirements
+): boolean {
+  const features = getRuntimeFeatures(runtimeId);
+  if (requirements.requiresBash && !features.hasBash) {
+    return false;
+  }
+  if (requirements.requiresFilesystem && !features.hasFilesystemTools) {
+    return false;
+  }
+  return true;
+}
+
+function filterCompatibleRuntimes(
+  runtimeIds: AgentRuntimeId[],
+  profileId?: string | null
+): AgentRuntimeId[] {
+  if (!profileId) {
+    return runtimeIds;
+  }
+
+  const profile = getProfile(profileId);
+  if (!profile) {
+    return [];
+  }
+
+  return runtimeIds.filter((runtimeId) =>
+    profileSupportsRuntime(profile, runtimeId)
+  );
+}
+
+async function checkRuntimeAvailability(
+  runtimeId: AgentRuntimeId
+): Promise<RuntimeAvailability> {
+  const states = await getRuntimeSetupStates();
+  if (!states[runtimeId]?.configured) {
+    return {
+      available: false,
+      reason: `${getRuntimeLabel(runtimeId)} is not configured`,
+    };
+  }
+
+  try {
+    const connection = await testRuntimeConnection(runtimeId);
+    if (connection.connected) {
+      return { available: true, reason: null };
+    }
+    return {
+      available: false,
+      reason:
+        connection.error ??
+        `${getRuntimeLabel(runtimeId)} is unavailable`,
+    };
+  } catch (error) {
+    return {
+      available: false,
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+async function getConfiguredCandidateRuntimes(
+  profileId?: string | null
+): Promise<AgentRuntimeId[]> {
+  const states = await getRuntimeSetupStates();
+  return filterCompatibleRuntimes(
+    listConfiguredRuntimeIds(states) as AgentRuntimeId[],
+    profileId
+  );
+}
+
+function buildTaskFallbackOrder(input: {
+  title: string;
+  description?: string | null;
+  profileId?: string | null;
+  requestedRuntimeId: AgentRuntimeId | null;
+  compatibleRuntimeIds: AgentRuntimeId[];
+}): AgentRuntimeId[] {
+  const alternates = input.compatibleRuntimeIds.filter(
+    (runtimeId) => runtimeId !== input.requestedRuntimeId
+  );
+  if (alternates.length === 0) {
+    return [];
+  }
+
+  const preferred = suggestRuntime(
+    input.title,
+    input.description,
+    input.profileId,
+    alternates,
+    "quality"
+  ).runtimeId;
+
+  return unique([
+    preferred,
+    ...alternates.filter(
+      (runtimeId) =>
+        input.requestedRuntimeId != null &&
+        getRuntimeCatalogEntry(runtimeId).providerId ===
+          getRuntimeCatalogEntry(input.requestedRuntimeId).providerId
+    ),
+    ...alternates,
+  ]);
+}
+
+function buildRuntimeFallbackReason(input: {
+  requestedRuntimeId: AgentRuntimeId | null;
+  effectiveRuntimeId: AgentRuntimeId;
+  unavailableReason: string | null;
+}): string | null {
+  if (!input.requestedRuntimeId) {
+    return null;
+  }
+
+  const requestedLabel = getRuntimeLabel(input.requestedRuntimeId);
+  const effectiveLabel = getRuntimeLabel(input.effectiveRuntimeId);
+  const reason = input.unavailableReason ?? `${requestedLabel} is unavailable`;
+  return `${reason}. Fell back to ${effectiveLabel}.`;
+}
+
+export async function resolveTaskExecutionTarget(input: {
+  title: string;
+  description?: string | null;
+  requestedRuntimeId?: string | null;
+  profileId?: string | null;
+  unavailableRuntimeIds?: string[];
+  unavailableReasons?: Record<string, string>;
+}): Promise<ResolvedExecutionTarget> {
+  const requestedRuntimeId = input.requestedRuntimeId
+    ? resolveAgentRuntime(input.requestedRuntimeId)
+    : null;
+  const requirements = detectRuntimeRequirements(input.profileId);
+  const unavailableRuntimeIds = new Set(
+    (input.unavailableRuntimeIds ?? []).map((runtimeId) =>
+      resolveAgentRuntime(runtimeId)
+    )
+  );
+  const configuredCandidates = await getConfiguredCandidateRuntimes(input.profileId);
+  const compatibleCandidates = configuredCandidates.filter((runtimeId) =>
+    runtimeMeetsRequirements(runtimeId, requirements)
+  );
+  const launchableCandidates = compatibleCandidates.filter(
+    (runtimeId) => !unavailableRuntimeIds.has(runtimeId)
+  );
+
+  if (compatibleCandidates.length === 0) {
+    throw new NoCompatibleRuntimeError(
+      "No compatible configured runtime is available for this task."
+    );
+  }
+
+  if (requestedRuntimeId) {
+    if (
+      compatibleCandidates.includes(requestedRuntimeId) &&
+      !unavailableRuntimeIds.has(requestedRuntimeId) &&
+      (await checkRuntimeAvailability(requestedRuntimeId)).available
+    ) {
+      return {
+        requestedRuntimeId,
+        effectiveRuntimeId: requestedRuntimeId,
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      };
+    }
+
+    const availability = unavailableRuntimeIds.has(requestedRuntimeId)
+      ? {
+          available: false,
+          reason:
+            input.unavailableReasons?.[requestedRuntimeId] ??
+            `${getRuntimeLabel(requestedRuntimeId)} is temporarily unavailable`,
+        }
+      : compatibleCandidates.includes(requestedRuntimeId)
+      ? await checkRuntimeAvailability(requestedRuntimeId)
+      : {
+          available: false,
+          reason: `${getRuntimeLabel(requestedRuntimeId)} does not support this task/profile`,
+        };
+    const fallbackOrder = buildTaskFallbackOrder({
+      title: input.title,
+      description: input.description,
+      profileId: input.profileId,
+      requestedRuntimeId,
+      compatibleRuntimeIds: launchableCandidates,
+    });
+
+    for (const candidate of fallbackOrder) {
+      const candidateAvailability = await checkRuntimeAvailability(candidate);
+      if (candidateAvailability.available) {
+        return {
+          requestedRuntimeId,
+          effectiveRuntimeId: candidate,
+          requestedModelId: null,
+          effectiveModelId: null,
+          fallbackApplied: true,
+          fallbackReason: buildRuntimeFallbackReason({
+            requestedRuntimeId,
+            effectiveRuntimeId: candidate,
+            unavailableReason: availability.reason,
+          }),
+        };
+      }
+    }
+
+    throw new NoCompatibleRuntimeError(
+      availability.reason ??
+        `No healthy alternate runtime is available for ${getRuntimeLabel(requestedRuntimeId)}.`
+    );
+  }
+
+  const routingPreference = await getRoutingPreference();
+  const suggested = suggestRuntime(
+    input.title,
+    input.description,
+    input.profileId,
+    launchableCandidates,
+    routingPreference
+  ).runtimeId;
+  const autoOrder = unique([
+    suggested,
+    ...launchableCandidates,
+  ]);
+
+  for (const candidate of autoOrder) {
+    const availability = await checkRuntimeAvailability(candidate);
+    if (availability.available) {
+      return {
+        requestedRuntimeId: null,
+        effectiveRuntimeId: candidate,
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      };
+    }
+  }
+
+  throw new RuntimeUnavailableError(
+    "No healthy runtime is currently available to execute this task."
+  );
+}
+
+export async function resolveResumeExecutionTarget(input: {
+  requestedRuntimeId?: string | null;
+  effectiveRuntimeId?: string | null;
+}): Promise<ResolvedExecutionTarget> {
+  const requestedRuntimeId = input.requestedRuntimeId
+    ? resolveAgentRuntime(input.requestedRuntimeId)
+    : null;
+  const resumeRuntimeId = input.effectiveRuntimeId
+    ? resolveAgentRuntime(input.effectiveRuntimeId)
+    : requestedRuntimeId ?? DEFAULT_AGENT_RUNTIME;
+  const availability = await checkRuntimeAvailability(resumeRuntimeId);
+
+  if (!availability.available) {
+    throw new RuntimeUnavailableError(
+      availability.reason ??
+        `${getRuntimeLabel(resumeRuntimeId)} is unavailable for resume. Use Retry for a fresh execution.`
+    );
+  }
+
+  return {
+    requestedRuntimeId,
+    effectiveRuntimeId: resumeRuntimeId,
+    requestedModelId: null,
+    effectiveModelId: null,
+    fallbackApplied: false,
+    fallbackReason: null,
+  };
+}
+
+function buildChatFallbackOrder(requestedModelId: string): string[] {
+  const fallbacks = CHAT_MODEL_FALLBACKS[requestedModelId] ?? [];
+  return unique([requestedModelId, ...fallbacks]);
+}
+
+function buildChatFallbackReason(input: {
+  requestedRuntimeId: AgentRuntimeId;
+  effectiveRuntimeId: AgentRuntimeId;
+  requestedModelId: string;
+  effectiveModelId: string;
+  unavailableReason: string | null;
+}): string | null {
+  if (
+    input.requestedRuntimeId === input.effectiveRuntimeId &&
+    input.requestedModelId === input.effectiveModelId
+  ) {
+    return null;
+  }
+
+  const requestedLabel = `${input.requestedModelId} on ${getRuntimeLabel(input.requestedRuntimeId)}`;
+  const effectiveLabel = `${input.effectiveModelId} on ${getRuntimeLabel(input.effectiveRuntimeId)}`;
+  const reason = input.unavailableReason ?? `${requestedLabel} is unavailable`;
+  return `${reason}. Using ${effectiveLabel} for this turn.`;
+}
+
+export async function resolveChatExecutionTarget(input: {
+  requestedRuntimeId?: string | null;
+  requestedModelId?: string | null;
+}): Promise<ResolvedExecutionTarget> {
+  const requestedModelId =
+    input.requestedModelId ??
+    (input.requestedRuntimeId
+      ? getRuntimeCatalogEntry(resolveAgentRuntime(input.requestedRuntimeId)).models.default
+      : DEFAULT_CHAT_MODEL);
+  const requestedRuntimeId = resolveAgentRuntime(
+    input.requestedRuntimeId ?? getRuntimeForModel(requestedModelId)
+  );
+
+  const modelOrder = buildChatFallbackOrder(requestedModelId);
+  let requestedAvailability: RuntimeAvailability | null = null;
+
+  for (const candidateModelId of modelOrder) {
+    const candidateRuntimeId = resolveAgentRuntime(
+      getRuntimeForModel(candidateModelId)
+    );
+    if (
+      candidateRuntimeId !== "claude-code" &&
+      candidateRuntimeId !== "openai-codex-app-server" &&
+      candidateRuntimeId !== "ollama"
+    ) {
+      continue;
+    }
+
+    const availability = await checkRuntimeAvailability(candidateRuntimeId);
+    if (
+      candidateRuntimeId === requestedRuntimeId &&
+      requestedAvailability === null
+    ) {
+      requestedAvailability = availability;
+    }
+    if (!availability.available) {
+      continue;
+    }
+
+    return {
+      requestedRuntimeId,
+      effectiveRuntimeId: candidateRuntimeId,
+      requestedModelId,
+      effectiveModelId: candidateModelId,
+      fallbackApplied:
+        candidateRuntimeId !== requestedRuntimeId ||
+        candidateModelId !== requestedModelId,
+      fallbackReason: buildChatFallbackReason({
+        requestedRuntimeId,
+        effectiveRuntimeId: candidateRuntimeId,
+        requestedModelId,
+        effectiveModelId: candidateModelId,
+        unavailableReason: requestedAvailability?.reason ?? null,
+      }),
+    };
+  }
+
+  throw new RequestedModelUnavailableError(
+    requestedAvailability?.reason ??
+      `No healthy runtime is available for ${requestedModelId}.`
+  );
+}

package/src/lib/agents/runtime/index.ts

@@ -2,6 +2,7 @@ import {
   DEFAULT_AGENT_RUNTIME,
   getRuntimeCapabilities,
   getRuntimeCatalogEntry,
+  getRuntimeFeatures,
   listRuntimeCatalog,
   resolveAgentRuntime,
   type AgentRuntimeId,
@@ -187,3 +188,6 @@ export async function testRuntimeConnection(
   }
   return adapter.testConnection();
 }
+
+export { getRuntimeFeatures };
+export type { RuntimeFeatures } from "./catalog";