mumucc 0.4.2 → 0.4.3

package/src/utils/messages.ts

@@ -90,6 +90,10 @@ type HookAttachmentWithName = Exclude<
   HookAttachment,
   HookPermissionDecisionAttachment
 >
+type LooseContentBlock = {
+  type: string
+  [key: string]: any
+}
 
 import type { APIError } from '@anthropic-ai/sdk'
 import type {
@@ -373,7 +377,7 @@ function baseCreateAssistantMessage({
     inference_geo: null,
     iterations: null,
     speed: null,
-  },
+  } as Usage,
 }: {
   content: BetaContentBlock[]
   isApiErrorMessage?: boolean
@@ -750,7 +754,7 @@ export function normalizeMessages(messages: Message[]): NormalizedMessage[] {
     switch (message.type) {
       case 'assistant': {
         isNewChain = isNewChain || message.message.content.length > 1
-        return message.message.content.map((_, index) => {
+        return message.message.content.map((_: any, index: number) => {
           const uuid = isNewChain
             ? deriveUUID(message.uuid, index)
             : message.uuid
@@ -794,7 +798,7 @@ export function normalizeMessages(messages: Message[]): NormalizedMessage[] {
         }
         isNewChain = isNewChain || message.message.content.length > 1
         let imageIndex = 0
-        return message.message.content.map((_, index) => {
+        return message.message.content.map((_: any, index: number) => {
           const isImage = _.type === 'image'
           // For image content blocks, extract just the ID for this image
           const imageId =
@@ -832,7 +836,7 @@ export function isToolUseRequestMessage(
   return (
     message.type === 'assistant' &&
     // Note: stop_reason === 'tool_use' is unreliable -- it's not always set correctly
-    message.message.content.some(_ => _.type === 'tool_use')
+    message.message.content.some((_: any) => _.type === 'tool_use')
   )
 }
 
@@ -879,9 +883,10 @@ export function reorderMessagesInUI(
 
   // First pass: group messages by tool use ID
   for (const message of messages) {
+    const currentMessage = message as any
     // Handle tool use messages
-    if (isToolUseRequestMessage(message)) {
-      const toolUseID = message.message.content[0]?.id
+    if (isToolUseRequestMessage(currentMessage)) {
+      const toolUseID = currentMessage.message.content[0]?.id
       if (toolUseID) {
         if (!toolUseGroups.has(toolUseID)) {
           toolUseGroups.set(toolUseID, {
@@ -891,63 +896,65 @@ export function reorderMessagesInUI(
             postHooks: [],
           })
         }
-        toolUseGroups.get(toolUseID)!.toolUse = message
+        toolUseGroups.get(toolUseID)!.toolUse = currentMessage
       }
       continue
     }
 
     // Handle pre-tool-use hooks
-    if (
-      isHookAttachmentMessage(message) &&
-      message.attachment.hookEvent === 'PreToolUse'
-    ) {
-      const toolUseID = message.attachment.toolUseID
-      if (!toolUseGroups.has(toolUseID)) {
-        toolUseGroups.set(toolUseID, {
-          toolUse: null,
-          preHooks: [],
-          toolResult: null,
-          postHooks: [],
-        })
+    if (isHookAttachmentMessage(currentMessage)) {
+      const attachmentMessage =
+        currentMessage as AttachmentMessage<HookAttachment>
+      if (attachmentMessage.attachment.hookEvent === 'PreToolUse') {
+        const toolUseID = attachmentMessage.attachment.toolUseID
+        if (!toolUseGroups.has(toolUseID)) {
+          toolUseGroups.set(toolUseID, {
+            toolUse: null,
+            preHooks: [],
+            toolResult: null,
+            postHooks: [],
+          })
+        }
+        toolUseGroups.get(toolUseID)!.preHooks.push(attachmentMessage)
+        continue
       }
-      toolUseGroups.get(toolUseID)!.preHooks.push(message)
-      continue
     }
 
     // Handle tool results
-    if (
-      message.type === 'user' &&
-      message.message.content[0]?.type === 'tool_result'
-    ) {
-      const toolUseID = message.message.content[0].tool_use_id
-      if (!toolUseGroups.has(toolUseID)) {
-        toolUseGroups.set(toolUseID, {
-          toolUse: null,
-          preHooks: [],
-          toolResult: null,
-          postHooks: [],
-        })
+    if ((message as any).type === 'user') {
+      const userMessage = message as UserMessage
+      if (userMessage.message.content[0]?.type === 'tool_result') {
+        const toolUseID = userMessage.message.content[0].tool_use_id
+        if (!toolUseGroups.has(toolUseID)) {
+          toolUseGroups.set(toolUseID, {
+            toolUse: null,
+            preHooks: [],
+            toolResult: null,
+            postHooks: [],
+          })
+        }
+        toolUseGroups.get(toolUseID)!.toolResult = userMessage
+        continue
       }
-      toolUseGroups.get(toolUseID)!.toolResult = message
-      continue
     }
 
     // Handle post-tool-use hooks
-    if (
-      isHookAttachmentMessage(message) &&
-      message.attachment.hookEvent === 'PostToolUse'
-    ) {
-      const toolUseID = message.attachment.toolUseID
-      if (!toolUseGroups.has(toolUseID)) {
-        toolUseGroups.set(toolUseID, {
-          toolUse: null,
-          preHooks: [],
-          toolResult: null,
-          postHooks: [],
-        })
+    if (isHookAttachmentMessage(currentMessage)) {
+      const attachmentMessage =
+        currentMessage as AttachmentMessage<HookAttachment>
+      if (attachmentMessage.attachment.hookEvent === 'PostToolUse') {
+        const toolUseID = attachmentMessage.attachment.toolUseID
+        if (!toolUseGroups.has(toolUseID)) {
+          toolUseGroups.set(toolUseID, {
+            toolUse: null,
+            preHooks: [],
+            toolResult: null,
+            postHooks: [],
+          })
+        }
+        toolUseGroups.get(toolUseID)!.postHooks.push(attachmentMessage)
+        continue
       }
-      toolUseGroups.get(toolUseID)!.postHooks.push(message)
-      continue
     }
   }
 
@@ -961,9 +968,10 @@ export function reorderMessagesInUI(
   const processedToolUses = new Set<string>()
 
   for (const message of messages) {
+    const currentMessage = message as any
     // Check if this is a tool use
-    if (isToolUseRequestMessage(message)) {
-      const toolUseID = message.message.content[0]?.id
+    if (isToolUseRequestMessage(currentMessage)) {
+      const toolUseID = currentMessage.message.content[0]?.id
       if (toolUseID && !processedToolUses.has(toolUseID)) {
         processedToolUses.add(toolUseID)
         const group = toolUseGroups.get(toolUseID)
@@ -981,36 +989,41 @@ export function reorderMessagesInUI(
     }
 
     // Check if this message is part of a tool use group
-    if (
-      isHookAttachmentMessage(message) &&
-      (message.attachment.hookEvent === 'PreToolUse' ||
-        message.attachment.hookEvent === 'PostToolUse')
-    ) {
-      // Skip - already handled in tool use groups
-      continue
+    if (isHookAttachmentMessage(currentMessage)) {
+      const attachmentMessage =
+        currentMessage as AttachmentMessage<HookAttachment>
+      if (
+        attachmentMessage.attachment.hookEvent === 'PreToolUse' ||
+        attachmentMessage.attachment.hookEvent === 'PostToolUse'
+      ) {
+        continue
+      }
     }
 
     if (
-      message.type === 'user' &&
-      message.message.content[0]?.type === 'tool_result'
+      (message as any).type === 'user' &&
+      (message as UserMessage).message.content[0]?.type === 'tool_result'
     ) {
       // Skip - already handled in tool use groups
       continue
     }
 
     // Handle api error messages (only keep the last one)
-    if (message.type === 'system' && message.subtype === 'api_error') {
+    if (
+      (message as any).type === 'system' &&
+      (message as any).subtype === 'api_error'
+    ) {
       const last = result.at(-1)
       if (last?.type === 'system' && last.subtype === 'api_error') {
-        result[result.length - 1] = message
+        result[result.length - 1] = currentMessage
       } else {
-        result.push(message)
+        result.push(currentMessage)
       }
       continue
     }
 
     // Add standalone messages
-    result.push(message)
+    result.push(currentMessage)
   }
 
   // Add synthetic streaming tool use messages
@@ -1122,9 +1135,11 @@ export function getSiblingToolUseIDs(
   }
 
   const unnormalizedMessage = messages.find(
-    (_): _ is AssistantMessage =>
-      _.type === 'assistant' &&
-      _.message.content.some(_ => _.type === 'tool_use' && _.id === toolUseID),
+        (_: AssistantMessage): _ is AssistantMessage =>
+          _.type === 'assistant' &&
+          _.message.content.some(
+            (block: any) => block.type === 'tool_use' && block.id === toolUseID,
+          ),
   )
   if (!unnormalizedMessage) {
     return new Set()
@@ -1132,14 +1147,16 @@ export function getSiblingToolUseIDs(
 
   const messageID = unnormalizedMessage.message.id
   const siblingMessages = messages.filter(
-    (_): _ is AssistantMessage =>
-      _.type === 'assistant' && _.message.id === messageID,
+        (_: AssistantMessage): _ is AssistantMessage =>
+          _.type === 'assistant' && _.message.id === messageID,
   )
 
   return new Set(
-    siblingMessages.flatMap(_ =>
-      _.message.content.filter(_ => _.type === 'tool_use').map(_ => _.id),
-    ),
+      siblingMessages.flatMap((message: AssistantMessage) =>
+        message.message.content
+          .filter((block: any) => block.type === 'tool_use')
+          .map((block: any) => block.id),
+      ),
   )
 }
 
@@ -1552,7 +1569,7 @@ function stripUnavailableToolReferencesFromUserMessage(
     block =>
       block.type === 'tool_result' &&
       Array.isArray(block.content) &&
-      block.content.some(c => {
+      block.content.some((c: any) => {
         if (!isToolReferenceBlock(c)) return false
         const toolName = (c as { tool_name?: string }).tool_name
         return (
@@ -1575,7 +1592,7 @@ function stripUnavailableToolReferencesFromUserMessage(
         }
 
         // Filter out tool_reference blocks for unavailable tools
-        const filteredContent = block.content.filter(c => {
+        const filteredContent = block.content.filter((c: any) => {
           if (!isToolReferenceBlock(c)) return true
           const rawToolName = (c as { tool_name?: string }).tool_name
           if (!rawToolName) return true
@@ -1704,7 +1721,7 @@ export function stripToolReferenceBlocksFromUserMessage(
 
         // Filter out tool_reference blocks from tool_result content
         const filteredContent = block.content.filter(
-          c => !isToolReferenceBlock(c),
+          (c: any) => !isToolReferenceBlock(c),
         )
 
         // If all content was tool_reference blocks, replace with a placeholder
@@ -1743,7 +1760,7 @@ export function stripCallerFieldFromAssistantMessage(
   message: AssistantMessage,
 ): AssistantMessage {
   const hasCallerField = message.message.content.some(
-    block =>
+    (block: any) =>
       block.type === 'tool_use' && 'caller' in block && block.caller !== null,
   )
 
@@ -1755,7 +1772,7 @@ export function stripCallerFieldFromAssistantMessage(
     ...message,
     message: {
       ...message.message,
-      content: message.message.content.map(block => {
+      content: message.message.content.map((block: any) => {
         if (block.type !== 'tool_use') {
           return block
         }
@@ -1804,7 +1821,7 @@ function ensureSystemReminderWrap(msg: UserMessage): UserMessage {
     }
   }
   let changed = false
-  const newContent = content.map(b => {
+  const newContent = content.map((b: any) => {
     if (b.type === 'text' && !b.text.startsWith('<system-reminder>')) {
       changed = true
       return { ...b, text: wrapInSystemReminder(b.text) }
@@ -2208,7 +2225,7 @@ export function normalizeMessagesForAPI(
             ...message,
             message: {
               ...message.message,
-              content: message.message.content.map(block => {
+              content: message.message.content.map((block: any) => {
                 if (block.type === 'tool_use') {
                   const tool = tools.find(t => toolMatchesName(t, block.name))
                   const normalizedInput = tool
@@ -2405,7 +2422,7 @@ function isToolResultMessage(msg: Message): boolean {
   }
   const content = msg.message.content
   if (typeof content === 'string') return false
-  return content.some(block => block.type === 'tool_result')
+  return content.some((block: any) => block.type === 'tool_result')
 }
 
 export function mergeUserMessages(a: UserMessage, b: UserMessage): UserMessage {
@@ -2656,7 +2673,8 @@ export function normalizeContentFromAPI(
   if (!contentBlocks) {
     return []
   }
-  return contentBlocks.map(contentBlock => {
+  return (contentBlocks as LooseContentBlock[]).map(
+    (contentBlock: LooseContentBlock) => {
     switch (contentBlock.type) {
       case 'tool_use': {
         if (
@@ -2747,7 +2765,8 @@ export function normalizeContentFromAPI(
       default:
         return contentBlock
     }
-  })
+    },
+  ) as BetaMessage['content']
 }
 
 export function isEmptyMessageText(text: string): boolean {
@@ -2789,6 +2808,8 @@ export function getToolUseID(message: NormalizedMessage): string | null {
       return message.subtype === 'informational'
         ? (message.toolUseID ?? null)
         : null
+    default:
+      return null
   }
 }
 
@@ -2849,8 +2870,8 @@ export function getAssistantMessageText(message: Message): string | null {
   if (Array.isArray(message.message.content)) {
     return (
       message.message.content
-        .filter(block => block.type === 'text')
-        .map(block => (block.type === 'text' ? block.text : ''))
+        .filter((block: any) => block.type === 'text')
+        .map((block: any) => (block.type === 'text' ? block.text : ''))
         .join('\n')
         .trim() || null
     )
@@ -2963,7 +2984,7 @@ export function handleMessageFromStream(
     // Capture complete thinking blocks for real-time display in transcript mode
     if (message.type === 'assistant') {
       const thinkingBlock = message.message.content.find(
-        block => block.type === 'thinking',
+        (block: any) => block.type === 'thinking',
       )
       if (thinkingBlock && thinkingBlock.type === 'thinking') {
         onStreamingThinking?.(() => ({
@@ -3112,7 +3133,7 @@ export function wrapMessagesInSystemReminder(
       }
     } else if (Array.isArray(msg.message.content)) {
       // For array content, wrap text blocks in system-reminder
-      const wrappedContent = msg.message.content.map(block => {
+      const wrappedContent = msg.message.content.map((block: any) => {
         if (block.type === 'text') {
           return {
             ...block,
@@ -4680,7 +4701,8 @@ export function isThinkingMessage(message: Message): boolean {
   if (message.type !== 'assistant') return false
   if (!Array.isArray(message.message.content)) return false
   return message.message.content.every(
-    block => block.type === 'thinking' || block.type === 'redacted_thinking',
+    (block: any) =>
+      block.type === 'thinking' || block.type === 'redacted_thinking',
   )
 }
 
@@ -4698,7 +4720,7 @@ export function countToolCalls(
     if (!msg) continue
     if (msg.type === 'assistant' && Array.isArray(msg.message.content)) {
       const hasToolUse = msg.message.content.some(
-        (block): block is ToolUseBlock =>
+        (block: any): block is ToolUseBlock =>
           block.type === 'tool_use' && block.name === toolName,
       )
       if (hasToolUse) {
@@ -4727,7 +4749,7 @@ export function hasSuccessfulToolCall(
     if (!msg) continue
     if (msg.type === 'assistant' && Array.isArray(msg.message.content)) {
       const toolUse = msg.message.content.find(
-        (block): block is ToolUseBlock =>
+        (block: any): block is ToolUseBlock =>
           block.type === 'tool_use' && block.name === toolName,
       )
       if (toolUse) {
@@ -4745,7 +4767,7 @@ export function hasSuccessfulToolCall(
     if (!msg) continue
     if (msg.type === 'user' && Array.isArray(msg.message.content)) {
       const toolResult = msg.message.content.find(
-        (block): block is ToolResultBlockParam =>
+        (block: any): block is ToolResultBlockParam =>
           block.type === 'tool_result' &&
           block.tool_use_id === mostRecentToolUseId,
       )
@@ -5164,7 +5186,7 @@ export function ensureToolResultPairing(
         result.at(-1)?.type !== 'assistant'
       ) {
         const stripped = msg.message.content.filter(
-          block =>
+          (block: any) =>
             !(
               typeof block === 'object' &&
               'type' in block &&
@@ -5223,7 +5245,7 @@ export function ensureToolResultPairing(
     // has no matching *_tool_result and the API rejects with e.g. "advisor
     // tool use without corresponding advisor_tool_result".
     const seenToolUseIds = new Set<string>()
-    const finalContent = msg.message.content.filter(block => {
+    const finalContent = msg.message.content.filter((block: any) => {
       if (block.type === 'tool_use') {
         if (allSeenToolUseIds.has(block.id)) {
           repaired = true
@@ -5404,13 +5426,13 @@ export function ensureToolResultPairing(
     const messageTypes = messages.map((m, idx) => {
       if (m.type === 'assistant') {
         const toolUses = m.message.content
-          .filter(b => b.type === 'tool_use')
-          .map(b => (b as ToolUseBlock | ToolUseBlockParam).id)
+          .filter((b: any) => b.type === 'tool_use')
+          .map((b: any) => (b as ToolUseBlock | ToolUseBlockParam).id)
         const serverToolUses = m.message.content
           .filter(
-            b => b.type === 'server_tool_use' || b.type === 'mcp_tool_use',
+            (b: any) => b.type === 'server_tool_use' || b.type === 'mcp_tool_use',
           )
-          .map(b => (b as { id: string }).id)
+          .map((b: any) => (b as { id: string }).id)
         const parts = [
           `id=${m.message.id}`,
           `tool_uses=[${toolUses.join(',')}]`,
@@ -5423,10 +5445,10 @@ export function ensureToolResultPairing(
       if (m.type === 'user' && Array.isArray(m.message.content)) {
         const toolResults = m.message.content
           .filter(
-            b =>
+            (b: any) =>
               typeof b === 'object' && 'type' in b && b.type === 'tool_result',
           )
-          .map(b => (b as ToolResultBlockParam).tool_use_id)
+          .map((b: any) => (b as ToolResultBlockParam).tool_use_id)
         if (toolResults.length > 0) {
           return `[${idx}] user(tool_results=[${toolResults.join(',')}])`
         }
@@ -5470,13 +5492,13 @@ export function stripAdvisorBlocks(
   const result = messages.map(msg => {
     if (msg.type !== 'assistant') return msg
     const content = msg.message.content
-    const filtered = content.filter(b => !isAdvisorBlock(b))
+    const filtered = content.filter((b: any) => !isAdvisorBlock(b))
     if (filtered.length === content.length) return msg
     changed = true
     if (
       filtered.length === 0 ||
       filtered.every(
-        b =>
+        (b: any) =>
           b.type === 'thinking' ||
           b.type === 'redacted_thinking' ||
           (b.type === 'text' && (!b.text || !b.text.trim())),

package/src/utils/model/agent.ts

@@ -13,6 +13,12 @@ import {
   getThirdPartyModelDisplayName,
   getAllThirdPartyModels,
 } from './thirdPartyProviders.js'
+import {
+  getDefaultSubagentProfileId,
+  getPlatformDefaultModelForProfile,
+  getPlatformProfile,
+  isProfileQualifiedModel,
+} from './platformProfiles.js'
 
 export const AGENT_MODEL_OPTIONS = [...MODEL_ALIASES, 'inherit'] as const
 export type AgentModelAlias = (typeof AGENT_MODEL_OPTIONS)[number]
@@ -28,6 +34,13 @@ export type AgentModelOption = {
  * the model from the parent thread.
  */
 export function getDefaultSubagentModel(): string {
+  const defaultProfile = getDefaultSubagentProfileId()
+  const defaultModel = defaultProfile
+    ? getPlatformDefaultModelForProfile(defaultProfile)
+    : undefined
+  if (defaultProfile && defaultModel) {
+    return `${defaultProfile}:${defaultModel}`
+  }
   return 'inherit'
 }
 
@@ -44,20 +57,41 @@ export function getAgentModel(
   parentModel: string,
   toolSpecifiedModel?: ModelAlias | string,
   permissionMode?: PermissionMode,
+  agentProfile?: string,
+  toolSpecifiedProfile?: string,
 ): string {
   if (process.env.CLAUDE_CODE_SUBAGENT_MODEL) {
     return parseUserSpecifiedModel(process.env.CLAUDE_CODE_SUBAGENT_MODEL)
   }
 
+  const explicitProfile = toolSpecifiedProfile ?? agentProfile
+
   // Third-party models (providerId:modelId) pass through directly.
   // They don't need Bedrock region prefix or Anthropic alias resolution.
-  if (toolSpecifiedModel && isThirdPartyModel(toolSpecifiedModel)) {
+  if (toolSpecifiedModel && (isThirdPartyModel(toolSpecifiedModel) || isProfileQualifiedModel(toolSpecifiedModel))) {
     return toolSpecifiedModel
   }
-  if (agentModel && isThirdPartyModel(agentModel)) {
+  if (agentModel && (isThirdPartyModel(agentModel) || isProfileQualifiedModel(agentModel))) {
     return agentModel
   }
 
+  const resolvedProfile = explicitProfile
+    ? getPlatformProfile(explicitProfile)
+    : undefined
+  const qualifyWithProfile = (profileId: string, modelValue: string): string => {
+    if (resolvedProfile?.provider.id === 'anthropic') {
+      return `${profileId}:${parseUserSpecifiedModel(modelValue)}`
+    }
+    return `${profileId}:${modelValue}`
+  }
+
+  if (explicitProfile && !toolSpecifiedModel && !agentModel) {
+    const profileDefaultModel = getPlatformDefaultModelForProfile(explicitProfile)
+    if (profileDefaultModel) {
+      return qualifyWithProfile(explicitProfile, profileDefaultModel)
+    }
+  }
+
   // Extract Bedrock region prefix from parent model to inherit for subagents.
   // This ensures subagents use the same cross-region inference profile (e.g., "eu.", "us.")
   // as the parent, which is required when IAM permissions only allow specific regions.
@@ -82,6 +116,9 @@ export function getAgentModel(
 
   // Prioritize tool-specified model if provided
   if (toolSpecifiedModel) {
+    if (explicitProfile) {
+      return qualifyWithProfile(explicitProfile, toolSpecifiedModel)
+    }
     if (aliasMatchesParentTier(toolSpecifiedModel, parentModel)) {
       return parentModel
     }
@@ -101,6 +138,10 @@ export function getAgentModel(
     })
   }
 
+  if (explicitProfile) {
+    return qualifyWithProfile(explicitProfile, agentModelWithExp)
+  }
+
   if (aliasMatchesParentTier(agentModelWithExp, parentModel)) {
     return parentModel
   }

package/src/utils/model/configs.ts

@@ -1,7 +1,7 @@
 import type { ModelName } from './model.js'
 import type { APIProvider } from './providers.js'
 
-export type ModelConfig = Record<APIProvider, ModelName>
+export type ModelConfig = Partial<Record<APIProvider, ModelName>>
 
 // @[MODEL LAUNCH]: Add a new CLAUDE_*_CONFIG constant here. Double check the correct model strings
 // here since the pattern may change.

package/src/utils/model/deprecation.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * Model deprecation utilities
  *

package/src/utils/model/fetchModels.ts

@@ -11,6 +11,8 @@
 import { logForDebugging } from '../debug.js'
 import type { ApiFormat } from './thirdPartyProviders.js'
 
+const LOCAL_PROVIDER_HOSTNAMES = new Set(['localhost', '127.0.0.1', '::1'])
+
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 export interface FetchedModel {
@@ -110,6 +112,14 @@ function isChatModel(modelId: string): boolean {
   return true
 }
 
+function isLocalProviderUrl(baseUrl: string): boolean {
+  try {
+    return LOCAL_PROVIDER_HOSTNAMES.has(new URL(baseUrl).hostname)
+  } catch {
+    return false
+  }
+}
+
 // ─── Fetch implementations ──────────────────────────────────────────────────
 
 /**
@@ -284,7 +294,7 @@ export async function fetchProviderModels(
     const result = await fetchOpenAIModels(baseUrl, apiKey, timeoutMs)
 
     // If standard /models failed and URL looks like Ollama, try /api/tags
-    if (result.models.length === 0 && baseUrl.includes('localhost')) {
+    if (result.models.length === 0 && isLocalProviderUrl(baseUrl)) {
       const ollamaResult = await fetchOllamaModels(baseUrl, timeoutMs)
       if (ollamaResult.models.length > 0) {
         return ollamaResult