@akiojin/gwt 4.10.0 → 4.12.0

package/src/cli/ui/utils/__tests__/branchFormatter.test.ts

@@ -0,0 +1,227 @@
+import { describe, expect, it } from "bun:test";
+import {
+  formatBranchItem,
+  getLatestActivityTimestamp,
+} from "../branchFormatter.js";
+import type { BranchInfo } from "../../types.js";
+
+// TDD: テストを先に書き、実装は後から行う
+
+const LOCAL_DATE_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false,
+});
+
+const formatLocalDateTime = (timestampMs: number): string => {
+  const date = new Date(timestampMs);
+  const parts = LOCAL_DATE_TIME_FORMATTER.formatToParts(date);
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value;
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  const hour = get("hour");
+  const minute = get("minute");
+  if (!year || !month || !day || !hour || !minute) {
+    return LOCAL_DATE_TIME_FORMATTER.format(date);
+  }
+  return `${year}-${month}-${day} ${hour}:${minute}`;
+};
+
+describe("branchFormatter", () => {
+  describe("buildLastToolUsageLabel with version", () => {
+    const baseBranch: BranchInfo = {
+      name: "feature/test",
+      type: "local",
+      isCurrent: false,
+      branchType: "feature",
+      hasRemoteCounterpart: false,
+    };
+
+    it("should format as 'ToolName@1.0.3 | 2024-01-08 12:00' with version", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "claude-code",
+          toolLabel: "Claude Code",
+          timestamp: new Date("2024-01-08T12:00:00").getTime(),
+          toolVersion: "1.0.3",
+        },
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBe(
+        `Claude@1.0.3 | ${formatLocalDateTime(
+          new Date("2024-01-08T12:00:00").getTime(),
+        )}`,
+      );
+    });
+
+    it("should format as 'ToolName@latest | 2024-01-08 12:00' when version is null", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "claude-code",
+          toolLabel: "Claude Code",
+          timestamp: new Date("2024-01-08T12:00:00").getTime(),
+          toolVersion: null,
+        },
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBe(
+        `Claude@latest | ${formatLocalDateTime(
+          new Date("2024-01-08T12:00:00").getTime(),
+        )}`,
+      );
+    });
+
+    it("should format as 'ToolName@latest | 2024-01-08 12:00' when version is undefined", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "claude-code",
+          toolLabel: "Claude Code",
+          timestamp: new Date("2024-01-08T12:00:00").getTime(),
+        },
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBe(
+        `Claude@latest | ${formatLocalDateTime(
+          new Date("2024-01-08T12:00:00").getTime(),
+        )}`,
+      );
+    });
+
+    it("should format Codex with version", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "codex-cli",
+          toolLabel: "Codex CLI",
+          timestamp: new Date("2024-01-08T15:30:00").getTime(),
+          toolVersion: "2.1.0-beta.1",
+        },
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBe(
+        `Codex@2.1.0-beta.1 | ${formatLocalDateTime(
+          new Date("2024-01-08T15:30:00").getTime(),
+        )}`,
+      );
+    });
+
+    it("should format Gemini with version", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "gemini-cli",
+          toolLabel: "Gemini CLI",
+          timestamp: new Date("2024-01-08T09:15:00").getTime(),
+          toolVersion: "0.5.0",
+        },
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBe(
+        `Gemini@0.5.0 | ${formatLocalDateTime(
+          new Date("2024-01-08T09:15:00").getTime(),
+        )}`,
+      );
+    });
+
+    it("should format custom tool with version", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "custom-tool",
+          toolLabel: "MyTool",
+          timestamp: new Date("2024-01-08T10:00:00").getTime(),
+          toolVersion: "1.0.0",
+        },
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBe(
+        `MyTool@1.0.0 | ${formatLocalDateTime(
+          new Date("2024-01-08T10:00:00").getTime(),
+        )}`,
+      );
+    });
+
+    it("should return null when lastToolUsage is undefined", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: undefined,
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBeNull();
+    });
+
+    it("should return null when lastToolUsage is null", () => {
+      const branch: BranchInfo = {
+        ...baseBranch,
+        lastToolUsage: null,
+      };
+
+      const item = formatBranchItem(branch);
+      expect(item.lastToolUsageLabel).toBeNull();
+    });
+  });
+
+  describe("getLatestActivityTimestamp", () => {
+    it("should return git timestamp when tool usage is undefined", () => {
+      const branch: BranchInfo = {
+        name: "feature/test",
+        type: "local",
+        isCurrent: false,
+        branchType: "feature",
+        hasRemoteCounterpart: false,
+        latestCommitTimestamp: 1704700800, // 2024-01-08 12:00:00 UTC in seconds
+      };
+
+      const result = getLatestActivityTimestamp(branch);
+      expect(result).toBe(1704700800);
+    });
+
+    it("should return tool timestamp when it is newer than git timestamp", () => {
+      const branch: BranchInfo = {
+        name: "feature/test",
+        type: "local",
+        isCurrent: false,
+        branchType: "feature",
+        hasRemoteCounterpart: false,
+        latestCommitTimestamp: 1704700800, // 2024-01-08 12:00:00 UTC in seconds
+        lastToolUsage: {
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          toolId: "claude-code",
+          toolLabel: "Claude Code",
+          timestamp: 1704704400000, // 2024-01-08 13:00:00 UTC in milliseconds
+        },
+      };
+
+      const result = getLatestActivityTimestamp(branch);
+      expect(result).toBe(1704704400); // converted to seconds
+    });
+  });
+});

package/src/cli/ui/utils/branchFormatter.ts

@@ -1,94 +1,9 @@
 import type {
   BranchInfo,
   BranchItem,
-  BranchType,
   WorktreeStatus,
   WorktreeInfo,
 } from "../types.js";
-import stringWidth from "string-width";
-
-// Icon mappings
-const branchIcons: Record<BranchType, string> = {
-  main: "⚡",
-  develop: "⚡",
-  feature: "✨",
-  bugfix: "🐛",
-  hotfix: "🔥",
-  release: "🚀",
-  other: "📌",
-};
-
-const worktreeIcons: Record<Exclude<WorktreeStatus, undefined>, string> = {
-  active: "🟢",
-  inaccessible: "🔴",
-};
-
-const changeIcons = {
-  current: "👉",
-  hasChanges: "💾",
-  unpushed: "📤",
-  openPR: "🔃",
-  mergedPR: "✅",
-  warning: "⚠️",
-};
-
-const remoteIcon = "☁";
-
-// Sync status icons
-const syncIcons = {
-  upToDate: "✓",
-  ahead: "↑",
-  behind: "↓",
-  diverged: "↕",
-  none: "-",
-  remoteOnly: "☁",
-};
-
-// Remote column markers
-const remoteMarkers = {
-  tracked: "🔗", // ローカル+同名リモートあり
-  localOnly: "💻", // ローカルのみ（リモートなし）
-  remoteOnly: "☁️", // リモートのみ（ローカルなし）
-};
-
-// Emoji width varies by terminal. Provide explicit minimum widths so we never
-// underestimate and accidentally push the row past the terminal columns.
-const iconWidthOverrides: Record<string, number> = {
-  // Remote icon
-  [remoteIcon]: 1,
-  // Branch type icons
-  "⚡": 1,
-  "✨": 1,
-  "🐛": 1,
-  "🔥": 1,
-  "🚀": 1,
-  "📌": 1,
-  // Worktree status icons
-  "🟢": 2,
-  "⚪": 2,
-  "🔴": 2,
-  // Change status icons
-  "👉": 1,
-  "💾": 1,
-  "📤": 1,
-  "🔃": 1,
-  "✅": 1,
-  "⚠️": 2,
-  "⚠": 1,
-  "🛡": 2,
-  "☑": 2,
-  "☐": 2,
-  // Remote markers
-  "🔗": 1,
-  "💻": 1,
-  "☁️": 1,
-};
-
-const getIconWidth = (icon: string): number => {
-  const baseWidth = stringWidth(icon);
-  const override = iconWidthOverrides[icon];
-  return override !== undefined ? Math.max(baseWidth, override) : baseWidth;
-};
 
 export interface FormatOptions {
   hasChanges?: boolean;
@@ -102,14 +17,42 @@ function mapToolLabel(toolId: string, toolLabel?: string): string {
   return "Custom";
 }
 
+const LOCAL_DATE_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false,
+});
+
+const formatLocalDateTimeParts = (date: Date): string => {
+  const parts = LOCAL_DATE_TIME_FORMATTER.formatToParts(date);
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value;
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  const hour = get("hour");
+  const minute = get("minute");
+
+  if (!year || !month || !day || !hour || !minute) {
+    return LOCAL_DATE_TIME_FORMATTER.format(date);
+  }
+
+  return `${year}-${month}-${day} ${hour}:${minute}`;
+};
+
+export function formatLocalDateTime(timestampMs: number): string {
+  const date = new Date(timestampMs);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  return formatLocalDateTimeParts(date);
+}
+
 function formatTimestamp(ts: number): string {
-  const date = new Date(ts);
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}`;
+  return formatLocalDateTime(ts);
 }
 
 function buildLastToolUsageLabel(
@@ -117,8 +60,11 @@ function buildLastToolUsageLabel(
 ): string | null {
   if (!usage) return null;
   const toolText = mapToolLabel(usage.toolId, usage.toolLabel);
+  // バージョン情報を追加（存在しない場合は@latest）
+  const versionSuffix = usage.toolVersion ? `@${usage.toolVersion}` : "@latest";
+  const labelWithVersion = `${toolText}${versionSuffix}`;
   const timestamp = usage.timestamp ? formatTimestamp(usage.timestamp) : null;
-  const parts = [toolText];
+  const parts = [labelWithVersion];
   if (timestamp) {
     parts.push(timestamp);
   }
@@ -146,106 +92,10 @@ export function formatBranchItem(
   options: FormatOptions = {},
 ): BranchItem {
   const hasChanges = options.hasChanges ?? false;
-  const COLUMN_WIDTH = 2; // Fixed width for each icon column
-
-  // Helper to pad icon to fixed width
-  const padIcon = (icon: string): string => {
-    const width = getIconWidth(icon);
-    const padding = Math.max(0, COLUMN_WIDTH - width);
-    return icon + " ".repeat(padding);
-  };
-
-  // Column 1: Branch type icon (always present)
-  const branchTypeIcon = padIcon(branchIcons[branch.branchType]);
-
-  // Column 2: Worktree status icon
-  let worktreeStatus: WorktreeStatus;
-  let worktreeIcon: string;
+  let worktreeStatus: WorktreeStatus | undefined;
   if (branch.worktree) {
-    if (branch.worktree.isAccessible === false) {
-      worktreeStatus = "inaccessible";
-      worktreeIcon = padIcon(worktreeIcons.inaccessible);
-    } else {
-      worktreeStatus = "active";
-      worktreeIcon = padIcon(worktreeIcons.active);
-    }
-  } else {
-    worktreeIcon = " ".repeat(COLUMN_WIDTH);
-  }
-
-  // Column 3: Change status icon (priority: ✏️ > ⬆️ > 🔀 > ✅ > ⚠️ > ⭐)
-  let changesIcon: string;
-  if (hasChanges) {
-    changesIcon = padIcon(changeIcons.hasChanges);
-  } else if (branch.hasUnpushedCommits) {
-    changesIcon = padIcon(changeIcons.unpushed);
-  } else if (branch.openPR) {
-    changesIcon = padIcon(changeIcons.openPR);
-  } else if (branch.mergedPR) {
-    changesIcon = padIcon(changeIcons.mergedPR);
-  } else if (branch.worktree?.isAccessible === false) {
-    changesIcon = padIcon(changeIcons.warning);
-  } else if (branch.isCurrent) {
-    changesIcon = padIcon(changeIcons.current);
-  } else {
-    changesIcon = " ".repeat(COLUMN_WIDTH);
-  }
-
-  // Column 4: Remote status (✓ for tracked, L for local-only, R for remote-only)
-  let remoteStatusStr: string;
-  if (branch.type === "remote") {
-    // リモートのみのブランチ
-    remoteStatusStr = padIcon(remoteMarkers.remoteOnly);
-  } else if (branch.hasRemoteCounterpart) {
-    // ローカルブランチで同名リモートあり
-    remoteStatusStr = padIcon(remoteMarkers.tracked);
-  } else {
-    // ローカルブランチでリモートなし
-    remoteStatusStr = padIcon(remoteMarkers.localOnly);
-  }
-
-  // Column 5: Sync status (=, ↑N, ↓N, ↕, -)
-  // 5文字固定幅（アイコン1文字 + 数字最大4桁）、9999超は「9999+」表示
-  const SYNC_COLUMN_WIDTH = 6; // アイコン1 + 数字4 + スペース1
-
-  // 数字を4桁以内にフォーマット（9999超は9999+）
-  const formatSyncNumber = (n: number): string => {
-    if (n > 9999) return "9999+";
-    return String(n);
-  };
-
-  // Sync列を固定幅でパディング
-  const padSyncColumn = (content: string): string => {
-    const width = stringWidth(content);
-    const padding = Math.max(0, SYNC_COLUMN_WIDTH - width);
-    return content + " ".repeat(padding);
-  };
-
-  let syncStatusStr: string;
-  if (branch.type === "remote") {
-    // リモートのみ → 比較不可
-    syncStatusStr = padSyncColumn(syncIcons.none);
-  } else if (branch.divergence) {
-    const { ahead, behind, upToDate } = branch.divergence;
-    if (upToDate) {
-      syncStatusStr = padSyncColumn(syncIcons.upToDate);
-    } else if (ahead > 0 && behind > 0) {
-      // diverged: ↕ のみ表示（詳細は別途表示可能）
-      syncStatusStr = padSyncColumn(syncIcons.diverged);
-    } else if (ahead > 0) {
-      // ahead: ↑N の形式
-      syncStatusStr = padSyncColumn(
-        `${syncIcons.ahead}${formatSyncNumber(ahead)}`,
-      );
-    } else {
-      // behind: ↓N の形式
-      syncStatusStr = padSyncColumn(
-        `${syncIcons.behind}${formatSyncNumber(behind)}`,
-      );
-    }
-  } else {
-    // divergence情報なし
-    syncStatusStr = padSyncColumn(syncIcons.none);
+    worktreeStatus =
+      branch.worktree.isAccessible === false ? "inaccessible" : "active";
   }
 
   // Build Local/Remote name for display
@@ -263,37 +113,8 @@ export function formatBranchItem(
     displayName = branch.name;
   }
 
-  // Build label with fixed-width columns
-  // Format: [Type][Worktree][Changes][Remote][Sync] DisplayName
-  const label = `${branchTypeIcon}${worktreeIcon}${changesIcon}${remoteStatusStr}${syncStatusStr}${displayName}`;
-
-  // Collect icons for compatibility
+  const label = displayName;
   const icons: string[] = [];
-  icons.push(branchIcons[branch.branchType]);
-  if (worktreeStatus) {
-    icons.push(
-      worktreeStatus === "active"
-        ? worktreeIcons.active
-        : worktreeIcons.inaccessible,
-    );
-  }
-  // Add change icon based on priority
-  if (hasChanges) {
-    icons.push(changeIcons.hasChanges);
-  } else if (branch.hasUnpushedCommits) {
-    icons.push(changeIcons.unpushed);
-  } else if (branch.openPR) {
-    icons.push(changeIcons.openPR);
-  } else if (branch.mergedPR) {
-    icons.push(changeIcons.mergedPR);
-  } else if (branch.worktree?.isAccessible === false) {
-    icons.push(changeIcons.warning);
-  } else if (branch.isCurrent) {
-    icons.push(changeIcons.current);
-  }
-  if (branch.type === "remote") {
-    icons.push(remoteIcon);
-  }
 
   // Determine sync status for BranchItem
   let syncStatus: BranchItem["syncStatus"];

package/src/cli/ui/utils/continueSession.ts

@@ -1,4 +1,15 @@
 import type { SessionData, ToolSessionEntry } from "../../../config/index.js";
+import type { SessionSearchOptions } from "../../../utils/session/index.js";
+import {
+  findLatestClaudeSession,
+  findLatestClaudeSessionId,
+  findLatestCodexSession,
+  findLatestCodexSessionId,
+  findLatestGeminiSession,
+  findLatestGeminiSessionId,
+  findLatestOpenCodeSession,
+} from "../../../utils/session/index.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 export interface ContinueSessionContext {
   history: ToolSessionEntry[];
@@ -6,6 +17,10 @@ export interface ContinueSessionContext {
   branch: string;
   toolId: string;
   repoRoot: string | null;
+  lookupLatestSessionId?: (params: {
+    toolId: string;
+    worktreePath: string;
+  }) => Promise<string | null>;
 }
 
 /**
@@ -41,6 +56,41 @@ export async function resolveContinueSessionId(
     return sessionData.lastSessionId;
   }
 
+  const latestEntry = findLatestBranchSession(history, branch, toolId);
+  const worktreePath = latestEntry?.worktreePath ?? null;
+  if (!worktreePath) {
+    return null;
+  }
+
+  if (context.lookupLatestSessionId) {
+    const lookupResult = await context.lookupLatestSessionId({
+      toolId,
+      worktreePath,
+    });
+    return lookupResult ?? null;
+  }
+
+  return lookupLatestSessionIdForTool(toolId, worktreePath);
+}
+
+async function lookupLatestSessionIdForTool(
+  toolId: string,
+  worktreePath: string,
+): Promise<string | null> {
+  try {
+    if (toolId === "claude-code") {
+      return await findLatestClaudeSessionId(worktreePath);
+    }
+    if (toolId === "codex-cli") {
+      return await findLatestCodexSessionId({ cwd: worktreePath });
+    }
+    if (toolId === "gemini-cli") {
+      return await findLatestGeminiSessionId(worktreePath);
+    }
+  } catch {
+    return null;
+  }
+
   return null;
 }
 
@@ -78,10 +128,10 @@ export function findLatestBranchSessionsByTool(
   const byBranch = history.filter((entry) => entry && entry.branch === branch);
   if (!byBranch.length) return [];
 
-  const scoped = worktreePath
+  const source = worktreePath
     ? byBranch.filter((entry) => entry.worktreePath === worktreePath)
     : byBranch;
-  const source = scoped.length ? scoped : byBranch;
+  if (!source.length) return [];
 
   const latestByTool = new Map<string, ToolSessionEntry>();
   for (const entry of source) {
@@ -98,3 +148,84 @@ export function findLatestBranchSessionsByTool(
     (a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0),
   );
 }
+
+export interface QuickStartRefreshContext {
+  branch: string;
+  worktreePath?: string | null;
+}
+
+export interface QuickStartSessionLookups {
+  findLatestCodexSession?: typeof findLatestCodexSession;
+  findLatestClaudeSession?: typeof findLatestClaudeSession;
+  findLatestGeminiSession?: typeof findLatestGeminiSession;
+  findLatestOpenCodeSession?: typeof findLatestOpenCodeSession;
+  listAllWorktrees?: typeof listAllWorktrees;
+}
+
+export async function refreshQuickStartEntries(
+  entries: ToolSessionEntry[],
+  context: QuickStartRefreshContext,
+  lookups: QuickStartSessionLookups = {},
+): Promise<ToolSessionEntry[]> {
+  if (!entries.length) return entries;
+  const worktreePath = context.worktreePath ?? null;
+  if (!worktreePath) return entries;
+
+  const lookupWorktrees = lookups.listAllWorktrees ?? listAllWorktrees;
+  let resolvedWorktrees: { path: string; branch: string }[] | null = null;
+  try {
+    const allWorktrees = await lookupWorktrees();
+    resolvedWorktrees = allWorktrees
+      .filter((entry) => entry?.path && entry?.branch)
+      .map((entry) => ({ path: entry.path, branch: entry.branch }));
+  } catch {
+    resolvedWorktrees = null;
+  }
+
+  const searchOptions: SessionSearchOptions = {
+    branch: context.branch,
+    ...(resolvedWorktrees && resolvedWorktrees.length > 0
+      ? { worktrees: resolvedWorktrees }
+      : {}),
+  };
+
+  const lookupCodex = lookups.findLatestCodexSession ?? findLatestCodexSession;
+  const lookupClaude =
+    lookups.findLatestClaudeSession ?? findLatestClaudeSession;
+  const lookupGemini =
+    lookups.findLatestGeminiSession ?? findLatestGeminiSession;
+  const lookupOpenCode =
+    lookups.findLatestOpenCodeSession ?? findLatestOpenCodeSession;
+
+  const updated = await Promise.all(
+    entries.map(async (entry) => {
+      let latest: { id: string; mtime: number } | null = null;
+      switch (entry.toolId) {
+        case "codex-cli":
+          latest = await lookupCodex(searchOptions);
+          break;
+        case "claude-code":
+          latest = await lookupClaude(worktreePath, searchOptions);
+          break;
+        case "gemini-cli":
+          latest = await lookupGemini(searchOptions);
+          break;
+        case "opencode":
+          latest = await lookupOpenCode(searchOptions);
+          break;
+        default:
+          return entry;
+      }
+
+      if (!latest?.id) return entry;
+      const updatedTimestamp = Math.max(entry.timestamp ?? 0, latest.mtime);
+      return {
+        ...entry,
+        sessionId: latest.id,
+        timestamp: updatedTimestamp,
+      };
+    }),
+  );
+
+  return updated.sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
+}

package/src/cli/ui/utils/modelOptions.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 import {
   getModelOptions,
   getDefaultInferenceForModel,