@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/tools/delegate-task/error-formatting.ts

@@ -1,51 +0,0 @@
-import type { DelegateTaskArgs } from "./types"
-
-/**
- * Context for error formatting.
- */
-export interface ErrorContext {
-  operation: string
-  args?: DelegateTaskArgs
-  sessionID?: string
-  agent?: string
-  category?: string
-}
-
-/**
- * Format an error with detailed context for debugging.
- */
-export function formatDetailedError(error: unknown, ctx: ErrorContext): string {
-  const message = error instanceof Error ? error.message : String(error)
-  const stack = error instanceof Error ? error.stack : undefined
-
-  const lines: string[] = [`${ctx.operation} failed`, "", `**Error**: ${message}`]
-
-  if (ctx.sessionID) {
-    lines.push(`**Session ID**: ${ctx.sessionID}`)
-  }
-
-  if (ctx.agent) {
-    lines.push(`**Agent**: ${ctx.agent}${ctx.category ? ` (category: ${ctx.category})` : ""}`)
-  }
-
-  if (ctx.args) {
-    lines.push("", "**Arguments**:")
-    lines.push(`- description: "${ctx.args.description}"`)
-    lines.push(`- category: ${ctx.args.category ?? "(none)"}`)
-    lines.push(`- subagent_type: ${ctx.args.subagent_type ?? "(none)"}`)
-    lines.push(`- run_in_background: ${ctx.args.run_in_background}`)
-    lines.push(`- load_skills: [${ctx.args.load_skills?.join(", ") ?? ""}]`)
-    if (ctx.args.session_id) {
-      lines.push(`- session_id: ${ctx.args.session_id}`)
-    }
-  }
-
-  if (stack) {
-    lines.push("", "**Stack Trace**:")
-    lines.push("```")
-    lines.push(stack.split("\n").slice(0, 10).join("\n"))
-    lines.push("```")
-  }
-
-  return lines.join("\n")
-}

package/src/tools/delegate-task/executor-types.ts

@@ -1,39 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-import type { CategoriesConfig, GitMasterConfig, BrowserAutomationProvider, AgentOverrides, BobAgentConfig } from "../../config/schema"
-import type { OpencodeClient } from "./types"
-
-export interface ExecutorContext {
-  manager: BackgroundManager
-  client: OpencodeClient
-  directory: string
-  userCategories?: CategoriesConfig
-  gitMasterConfig?: GitMasterConfig
-  bobJuniorModel?: string
-  browserProvider?: BrowserAutomationProvider
-  agentOverrides?: AgentOverrides
-  bobAgentConfig?: BobAgentConfig
-  onSyncSessionCreated?: (event: { sessionID: string; parentID: string; title: string }) => Promise<void>
-  syncPollTimeoutMs?: number
-}
-
-export interface ParentContext {
-  sessionID: string
-  messageID: string
-  agent?: string
-  model?: { providerID: string; modelID: string; variant?: string }
-}
-
-export interface SessionMessage {
-  info?: {
-    id?: string
-    role?: string
-    time?: { created?: number }
-    finish?: string
-    agent?: string
-    model?: { providerID: string; modelID: string; variant?: string }
-    modelID?: string
-    providerID?: string
-    variant?: string
-  }
-  parts?: Array<{ type?: string; text?: string }>
-}

package/src/tools/delegate-task/executor.ts

@@ -1,16 +0,0 @@
-export type { ExecutorContext, ParentContext } from "./executor-types"
-
-export { resolveSkillContent } from "./skill-resolver"
-export { resolveParentContext } from "./parent-context-resolver"
-
-export { executeBackgroundContinuation } from "./background-continuation"
-export { executeSyncContinuation } from "./sync-continuation"
-
-export { executeUnstableAgentTask } from "./unstable-agent-task"
-export { executeBackgroundTask } from "./background-task"
-export { executeSyncTask } from "./sync-task"
-
-export { resolveCategoryExecution } from "./category-resolver"
-export type { CategoryResolutionResult } from "./category-resolver"
-
-export { resolveSubagentExecution } from "./subagent-resolver"

package/src/tools/delegate-task/fallback-entry-resolution.ts

@@ -1,27 +0,0 @@
-import { findMostSpecificFallbackEntry } from "../../shared/fallback-chain-from-models"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import type { DelegatedModelConfig } from "./types"
-
-export function resolveEffectiveFallbackEntry(input: {
-  categoryModel: DelegatedModelConfig | undefined
-  configuredFallbackChain: FallbackEntry[] | undefined
-  resolution:
-    | { skipped: true }
-    | { fallbackEntry?: FallbackEntry; matchedFallback?: boolean }
-    | undefined
-}): FallbackEntry | undefined {
-  const { categoryModel, configuredFallbackChain, resolution } = input
-
-  const resolutionSkipped = resolution && "skipped" in resolution
-  const resolvedFallbackEntry = resolution && !resolutionSkipped ? resolution.fallbackEntry : undefined
-  const matchedFallback = resolution && !resolutionSkipped ? resolution.matchedFallback === true : false
-
-  if (!matchedFallback || !categoryModel) {
-    return undefined
-  }
-
-  return resolvedFallbackEntry
-    ?? (configuredFallbackChain
-      ? findMostSpecificFallbackEntry(categoryModel.providerID, categoryModel.modelID, configuredFallbackChain)
-      : undefined)
-}

package/src/tools/delegate-task/fallback-entry-settings.ts

@@ -1,20 +0,0 @@
-import type { DelegatedModelConfig } from "./types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-
-export function applyFallbackEntrySettings(input: {
-  categoryModel: DelegatedModelConfig
-  effectiveEntry: FallbackEntry
-  variantOverride?: string
-}): DelegatedModelConfig {
-  const { categoryModel, effectiveEntry, variantOverride } = input
-
-  return {
-    ...categoryModel,
-    variant: variantOverride ?? effectiveEntry.variant ?? categoryModel.variant,
-    reasoningEffort: effectiveEntry.reasoningEffort ?? categoryModel.reasoningEffort,
-    temperature: effectiveEntry.temperature ?? categoryModel.temperature,
-    top_p: effectiveEntry.top_p ?? categoryModel.top_p,
-    maxTokens: effectiveEntry.maxTokens ?? categoryModel.maxTokens,
-    thinking: effectiveEntry.thinking ?? categoryModel.thinking,
-  }
-}

package/src/tools/delegate-task/google-categories.ts

@@ -1,130 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const VISUAL_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on VISUAL/UI tasks.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). This category is not for cheap bounded edits.
-</Routing_Policy>
-
-<DESIGN_SYSTEM_WORKFLOW_MANDATE>
-## YOU ARE A VISUAL ENGINEER. FOLLOW THIS WORKFLOW OR YOUR OUTPUT IS REJECTED.
-
-**YOUR FAILURE MODE**: You skip design system analysis and jump straight to writing components with hardcoded colors, arbitrary spacing, and ad-hoc font sizes. The result is INCONSISTENT GARBAGE that looks like 5 different people built it. THIS STOPS NOW.
-
-**EVERY visual task follows this EXACT workflow. VIOLATION = BROKEN OUTPUT.**
-
-### PHASE 1: ANALYZE THE DESIGN SYSTEM (MANDATORY FIRST ACTION)
-
-**BEFORE writing a SINGLE line of CSS, HTML, JSX, Svelte, or component code - you MUST:**
-
-1. **SEARCH for the design system.** Use Grep, Glob, Read - actually LOOK:
-   - Design tokens: colors, spacing, typography, shadows, border-radii
-   - Theme files: CSS variables, Tailwind config, \`theme.ts\`, styled-components theme, design tokens file
-   - Shared/base components: Button, Card, Input, Layout primitives
-   - Existing UI patterns: How are pages structured? What spacing grid? What color usage?
-
-2. **READ at minimum 5-10 existing UI components.** Understand:
-   - Naming conventions (BEM? Atomic? Utility-first? Component-scoped?)
-   - Spacing system (4px grid? 8px? Tailwind scale? CSS variables?)
-   - Color usage (semantic tokens? Direct hex? Theme references?)
-   - Typography scale (heading levels, body, caption - how many? What font stack?)
-   - Component composition patterns (slots? children? compound components?)
-
-**DO NOT proceed to Phase 2 until you can answer ALL of these. If you cannot, you have not explored enough. EXPLORE MORE.**
-
-### PHASE 2: NO DESIGN SYSTEM? BUILD ONE. NOW.
-
-If Phase 1 reveals NO coherent design system (or scattered, inconsistent patterns):
-
-1. **STOP. Do NOT build the requested UI yet.**
-2. **Extract what exists** - even inconsistent patterns have salvageable decisions.
-3. **Create a minimal design system FIRST:**
-   - Color palette: primary, secondary, neutral, semantic (success/warning/error/info)
-   - Typography scale: heading levels (h1-h4 minimum), body, small, caption
-   - Spacing scale: consistent increments (4px or 8px base)
-   - Border radii, shadows, transitions - systematic, not random
-   - Component primitives: the reusable building blocks
-4. **Commit/save the design system, THEN proceed to Phase 3.**
-
-A design system is NOT optional overhead. It is the FOUNDATION. Building UI without one is like building a house on sand. It WILL collapse into inconsistency.
-
-### PHASE 3: BUILD WITH THE SYSTEM. NEVER AROUND IT.
-
-**NOW and ONLY NOW** - implement the requested visual work:
-
-| Element | CORRECT | WRONG (WILL BE REJECTED) |
-|---------|---------|--------------------------|
-| Color | Design token / CSS variable | Hardcoded \`#3b82f6\`, \`rgb(59,130,246)\` |
-| Spacing | System value (\`space-4\`, \`gap-md\`, \`var(--spacing-4)\`) | Arbitrary \`margin: 13px\`, \`padding: 7px\` |
-| Typography | Scale value (\`text-lg\`, \`heading-2\`, token) | Ad-hoc \`font-size: 17px\` |
-| Component | Extend/compose from existing primitives | One-off div soup with inline styles |
-| Border radius | System token | Random \`border-radius: 6px\` |
-
-**IF the design requires something OUTSIDE the current system:**
-- **Extend the system FIRST** - add the new token/primitive
-- **THEN use the new token** in your component
-- **NEVER one-off override.** That is how design systems die.
-
-### PHASE 4: VERIFY BEFORE CLAIMING DONE
-
-BEFORE reporting visual work as complete, answer these:
-
-- [ ] Does EVERY color reference a design token or CSS variable?
-- [ ] Does EVERY spacing use the system scale?
-- [ ] Does EVERY component follow the existing composition pattern?
-- [ ] Would a designer see CONSISTENCY across old and new components?
-- [ ] Are there ZERO hardcoded magic numbers for visual properties?
-
-**If ANY answer is NO - FIX IT. You are NOT done.**
-
-</DESIGN_SYSTEM_WORKFLOW_MANDATE>
-
-<DESIGN_QUALITY>
-Design-first mindset (AFTER design system is established):
-- Bold aesthetic choices over safe defaults
-- Unexpected layouts, asymmetry, grid-breaking elements
-- Distinctive typography (avoid: Arial, Inter, Roboto, Space Grotesk)
-- Cohesive color palettes with sharp accents
-- High-impact animations with staggered reveals
-- Atmosphere: gradient meshes, noise textures, layered transparencies
-
-AVOID: Generic fonts, purple gradients on white, predictable layouts, cookie-cutter patterns.
-</DESIGN_QUALITY>
-</Category_Context>`
-
-const ARTISTRY_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on HIGHLY CREATIVE / ARTISTIC tasks.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). Reserve for high-effort creative work.
-</Routing_Policy>
-
-Artistic genius mindset:
-- Push far beyond conventional boundaries
-- Explore radical, unconventional directions
-- Surprise and delight: unexpected twists, novel combinations
-- Rich detail and vivid expression
-- Break patterns deliberately when it serves the creative vision
-
-Approach:
-- Generate diverse, bold options first
-- Embrace ambiguity and wild experimentation
-- Balance novelty with coherence
-- This is for tasks requiring exceptional creativity
-</Category_Context>`
-
-export const GOOGLE_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "visual-engineering",
-    config: {},
-    description: "Frontend and UI systems work with design-system discipline. Uses coder execution contour.",
-    promptAppend: VISUAL_CATEGORY_PROMPT_APPEND,
-  },
-  {
-    name: "artistry",
-    config: {},
-    description: "High-effort creative problem solving beyond standard patterns. Uses coder execution contour.",
-    promptAppend: ARTISTRY_CATEGORY_PROMPT_APPEND,
-  },
-]

package/src/tools/delegate-task/index.ts

@@ -1,4 +0,0 @@
-export { createDelegateTask, resolveCategoryConfig, buildSystemContent, buildTaskPrompt } from "./tools"
-export type { DelegateTaskToolOptions, SyncSessionCreatedEvent, BuildSystemContentInput } from "./tools"
-export type * from "./types"
-export * from "./constants"

package/src/tools/delegate-task/kimi-categories.ts

@@ -1,40 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const WRITING_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on WRITING / PROSE tasks.
-
-<Routing_Policy>
-Executor contour: coder (fast bounded execution) for focused docs and prose updates.
-</Routing_Policy>
-
-Wordsmith mindset:
-- Clear, flowing prose
-- Appropriate tone and voice
-- Engaging and readable
-- Proper structure and organization
-
-Approach:
-- Understand the audience
-- Draft with care
-- Polish for clarity and impact
-- Documentation, READMEs, articles, technical writing
-
-ANTI-AI-SLOP RULES (NON-NEGOTIABLE):
-- NEVER use em dashes (-) or en dashes (-). Use commas, periods, ellipses, or line breaks instead. Zero tolerance.
-- Remove AI-sounding phrases: "delve", "it's important to note", "I'd be happy to", "certainly", "please don't hesitate", "leverage", "utilize", "in order to", "moving forward", "circle back", "at the end of the day", "robust", "streamline", "facilitate"
-- Pick plain words. "Use" not "utilize". "Start" not "commence". "Help" not "facilitate".
-- Use contractions naturally: "don't" not "do not", "it's" not "it is".
-- Vary sentence length. Don't make every sentence the same length.
-- NEVER start consecutive sentences with the same word.
-- No filler openings: skip "In today's world...", "As we all know...", "It goes without saying..."
-- Write like a human, not a corporate template.
-</Category_Context>`
-
-export const KIMI_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "writing",
-    config: {},
-    description: "Documentation and prose tasks with bounded scope. Uses coder execution contour.",
-    promptAppend: WRITING_CATEGORY_PROMPT_APPEND,
-  },
-]

package/src/tools/delegate-task/model-selection.ts

@@ -1,201 +0,0 @@
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { normalizeModel } from "../../shared/model-normalization"
-import { fuzzyMatchModel } from "../../shared/model-availability"
-import { transformModelForProvider } from "../../shared/provider-model-id-transform"
-import { hasConnectedProvidersCache, hasProviderModelsCache, readConnectedProvidersCache } from "../../shared/connected-providers-cache"
-import { log } from "../../shared/logger"
-import { parseModelString, parseVariantFromModelID } from "./model-string-parser"
-
-function isExplicitHighModel(model: string): boolean {
-  return /(?:^|\/)[^/]+-high$/.test(model)
-}
-
-function getExplicitHighBaseModel(model: string): string | null {
-  return isExplicitHighModel(model) ? model.replace(/-high$/, "") : null
-}
-
-function parseUserFallbackModel(fallbackModel: string): {
-  baseModel: string
-  providerHint?: string[]
-  variant?: string
-} | undefined {
-  const normalizedFallback = normalizeModel(fallbackModel)
-  if (!normalizedFallback) {
-    return undefined
-  }
-
-  const parsedFullModel = parseModelString(normalizedFallback)
-  if (parsedFullModel) {
-    return {
-      baseModel: `${parsedFullModel.providerID}/${parsedFullModel.modelID}`,
-      providerHint: [parsedFullModel.providerID],
-      variant: parsedFullModel.variant,
-    }
-  }
-
-  const parsedModel = parseVariantFromModelID(normalizedFallback)
-  if (!parsedModel.modelID) {
-    return undefined
-  }
-
-  return {
-    baseModel: parsedModel.modelID,
-    variant: parsedModel.variant,
-  }
-}
-
-
-export function resolveModelForDelegateTask(input: {
-  userModel?: string
-  userFallbackModels?: string[]
-  categoryDefaultModel?: string
-  isUserConfiguredCategoryModel?: boolean
-  fallbackChain?: FallbackEntry[]
-  availableModels: Set<string>
-  systemDefaultModel?: string
-}): { model: string; variant?: string; fallbackEntry?: FallbackEntry; matchedFallback?: boolean } | { skipped: true } | undefined {
-  const userModel = normalizeModel(input.userModel)
-  if (userModel) {
-    const parsed = parseUserFallbackModel(userModel)
-    if (parsed?.variant) {
-      return { model: parsed.baseModel, variant: parsed.variant }
-    }
-    return { model: userModel }
-  }
-
-  const connectedProviders = input.availableModels.size === 0 ? readConnectedProvidersCache() : null
-
-  // Before provider cache is created (first run), skip model resolution entirely.
-  // OpenCode will use its system default model when no model is specified in the prompt.
-  if (input.availableModels.size === 0 && !hasProviderModelsCache() && !hasConnectedProvidersCache()) {
-    return { skipped: true }
-  }
-
-  const categoryDefault = normalizeModel(input.categoryDefaultModel)
-  const explicitHighBaseModel = categoryDefault ? getExplicitHighBaseModel(categoryDefault) : null
-  const explicitHighModel = explicitHighBaseModel ? categoryDefault : undefined
-  if (categoryDefault) {
-    if (input.isUserConfiguredCategoryModel) {
-      log("[resolveModelForDelegateTask] using user-configured category model (bypass validation)", {
-        categoryDefaultModel: categoryDefault,
-      })
-      const parsed = parseUserFallbackModel(categoryDefault)
-      if (parsed?.variant) {
-        return { model: parsed.baseModel, variant: parsed.variant }
-      }
-      return { model: categoryDefault }
-    }
-
-    if (input.availableModels.size === 0) {
-      const categoryProvider = categoryDefault.includes("/") ? categoryDefault.split("/")[0] : undefined
-      if (!connectedProviders || !categoryProvider || connectedProviders.includes(categoryProvider)) {
-        return { model: categoryDefault }
-      }
-
-      log("[resolveModelForDelegateTask] skipping disconnected category default on cold cache", {
-        categoryDefault,
-        connectedProviders,
-      })
-    }
-
-    const parts = categoryDefault.split("/")
-    const providerHint = parts.length >= 2 ? [parts[0]] : undefined
-    const match = fuzzyMatchModel(categoryDefault, input.availableModels, providerHint)
-    if (match) {
-      if (isExplicitHighModel(categoryDefault) && match !== categoryDefault) {
-        return { model: categoryDefault }
-      }
-
-      return { model: match }
-    }
-  }
-
-  const userFallbackModels = input.userFallbackModels
-  if (userFallbackModels && userFallbackModels.length > 0) {
-    if (input.availableModels.size === 0) {
-      for (const fallbackModel of userFallbackModels) {
-        const parsedFallback = parseUserFallbackModel(fallbackModel)
-        if (!parsedFallback) continue
-
-        if (
-          connectedProviders &&
-          parsedFallback.providerHint &&
-          !parsedFallback.providerHint.some((provider) => connectedProviders.includes(provider))
-        ) {
-          continue
-        }
-
-        return { model: parsedFallback.baseModel, variant: parsedFallback.variant, matchedFallback: true }
-      }
-    } else {
-      for (const fallbackModel of userFallbackModels) {
-        const parsedFallback = parseUserFallbackModel(fallbackModel)
-        if (!parsedFallback) continue
-
-        const match = fuzzyMatchModel(parsedFallback.baseModel, input.availableModels, parsedFallback.providerHint)
-        if (match) {
-          return { model: match, variant: parsedFallback.variant, matchedFallback: true }
-        }
-      }
-    }
-  }
-
-  const fallbackChain = input.fallbackChain
-  if (fallbackChain && fallbackChain.length > 0) {
-    if (input.availableModels.size === 0) {
-      if (connectedProviders) {
-        const connectedSet = new Set(connectedProviders)
-        for (const entry of fallbackChain) {
-          for (const provider of entry.providers) {
-            if (connectedSet.has(provider)) {
-              const transformedModelId = transformModelForProvider(provider, entry.model)
-              log("[resolveModelForDelegateTask] fallback chain resolved via connected provider", {
-                provider,
-                model: entry.model,
-              })
-              return { model: `${provider}/${transformedModelId}`, variant: entry.variant, fallbackEntry: entry, matchedFallback: true }
-            }
-          }
-        }
-        log("[resolveModelForDelegateTask] no connected provider found in fallback chain")
-      } else {
-        const first = fallbackChain[0]
-        const provider = first?.providers?.[0]
-        if (provider) {
-          const transformedModelId = transformModelForProvider(provider, first.model)
-          return { model: `${provider}/${transformedModelId}`, variant: first.variant, fallbackEntry: first, matchedFallback: true }
-        }
-      }
-    } else {
-      for (const entry of fallbackChain) {
-        for (const provider of entry.providers) {
-          const fullModel = `${provider}/${entry.model}`
-          const match = fuzzyMatchModel(fullModel, input.availableModels, [provider])
-          if (match) {
-            if (explicitHighModel && entry.variant === "high" && match === explicitHighBaseModel) {
-              return { model: explicitHighModel, fallbackEntry: entry, matchedFallback: true }
-            }
-
-            return { model: match, variant: entry.variant, fallbackEntry: entry, matchedFallback: true }
-          }
-        }
-
-        const crossProviderMatch = fuzzyMatchModel(entry.model, input.availableModels)
-        if (crossProviderMatch) {
-          if (explicitHighModel && entry.variant === "high" && crossProviderMatch === explicitHighBaseModel) {
-            return { model: explicitHighModel, fallbackEntry: entry, matchedFallback: true }
-          }
-
-          return { model: crossProviderMatch, variant: entry.variant, fallbackEntry: entry, matchedFallback: true }
-        }
-      }
-    }
-  }
-
-  const systemDefaultModel = normalizeModel(input.systemDefaultModel)
-  if (systemDefaultModel) {
-    return { model: systemDefaultModel }
-  }
-
-  return undefined
-}

package/src/tools/delegate-task/model-string-parser.ts

@@ -1,63 +0,0 @@
-const KNOWN_VARIANTS = new Set([
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-  "minimal",
-  "none",
-  "auto",
-  "thinking",
-])
-
-export function parseVariantFromModelID(rawModelID: string): { modelID: string; variant?: string } {
-  const trimmedModelID = rawModelID.trim()
-  if (!trimmedModelID) {
-    return { modelID: "" }
-  }
-
-  const parenthesizedVariant = trimmedModelID.match(/^(.*)\(([^()]+)\)\s*$/)
-  if (parenthesizedVariant) {
-    const modelID = parenthesizedVariant[1]?.trim() ?? ""
-    const variant = parenthesizedVariant[2]?.trim()
-    return variant ? { modelID, variant } : { modelID }
-  }
-
-  const spaceVariant = trimmedModelID.match(/^(.*\S)\s+([a-z][a-z0-9_-]*)$/i)
-  if (spaceVariant) {
-    const modelID = spaceVariant[1]?.trim() ?? ""
-    const variant = spaceVariant[2]?.trim().toLowerCase()
-    if (variant && KNOWN_VARIANTS.has(variant)) {
-      return { modelID, variant }
-    }
-  }
-
-  return { modelID: trimmedModelID }
-}
-
-export function parseModelString(
-  model: string,
-): { providerID: string; modelID: string; variant?: string } | undefined {
-  const trimmedModel = model.trim()
-  if (!trimmedModel) return undefined
-
-  const parts = trimmedModel.split("/")
-  if (parts.length < 2) {
-    return undefined
-  }
-
-  const providerID = parts[0]?.trim()
-  const rawModelID = parts.slice(1).join("/").trim()
-  if (!providerID || !rawModelID) {
-    return undefined
-  }
-
-  const parsedModel = parseVariantFromModelID(rawModelID)
-  if (!parsedModel.modelID) {
-    return undefined
-  }
-
-  return parsedModel.variant
-    ? { providerID, modelID: parsedModel.modelID, variant: parsedModel.variant }
-    : { providerID, modelID: parsedModel.modelID }
-}