29571051485

Committed 17 Jul 2026 09:44AM UTC coverage: 71.713% (+0.5%) from 71.204%

Build # 29571051485

Build Type

Pull #2475

github

Committed by

samuv

Commit Message

fix(chat): harden Effect runtime adapters after external review

Make readiness and runtime retrieval atomic, type adapter programs against
ChatServices, and tighten domain-error narrowing plus agent/settings edge cases.

Co-authored-by: Cursor <cursoragent@cursor.com>

Pull Request Pull Request #2475: refactor(chat): migrate main-process chat to Effect domain services

Coverage Stats

5476 of 8187 branches covered (66.89%)

871 of 1363 new or added lines in 42 files covered. (63.9%)

1 existing line in 1 file now uncovered.

8153 of 11369 relevant lines covered (71.71%)

137.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

6.25

/main/src/chat/settings-storage.ts

import { Effect } from 'effect'
import { runChatSyncOr, runChatPromiseOr, runChatToResultSync } from './runtime'
import { SettingsService } from './settings/settings-service'
import type {
  ChatSettingsProvider,
  ChatSettingsSelectedModel,
} from './settings/settings-service'
import {
  CHAT_PROVIDER_INFO,
  LOCAL_PROVIDER_IDS,
  type LocalProviderId,
} from './constants'

type ProviderId = (typeof CHAT_PROVIDER_INFO)[number]['id']

function isLocalProvider(
  providerId: ProviderId
): providerId is LocalProviderId {
  return LOCAL_PROVIDER_IDS.includes(providerId as LocalProviderId)
}

function defaultChatSettings(providerId: ProviderId): ChatSettingsProvider {
  if (isLocalProvider(providerId)) {
    return { providerId, endpointURL: '', enabledTools: [] }
  }
  return {
    providerId,
    apiKey: '',
    enabledTools: [],
  }
}

const EMPTY_SELECTED_MODEL: ChatSettingsSelectedModel = {
  provider: '',
  model: '',
}

export function getChatSettings(providerId: ProviderId): ChatSettingsProvider {
  return runChatSyncOr(
    SettingsService.getChatSettings(providerId),
    defaultChatSettings(providerId)
  )
}

export function clearChatSettings(providerId?: ProviderId): {
  success: boolean
  error?: string
} {
  return runChatToResultSync(
    SettingsService.clearChatSettings(providerId).pipe(Effect.as({}))
  )
}

export function getSelectedModel(): ChatSettingsSelectedModel {
  return runChatSyncOr(SettingsService.getSelectedModel(), EMPTY_SELECTED_MODEL)
}

export function saveSelectedModel(
  provider: string,
  model: string
): { success: boolean; error?: string } {
  return runChatToResultSync(
    SettingsService.saveSelectedModel(provider, model).pipe(Effect.as({}))
  )
}

export function saveEnabledMcpTools(
  serverName: string,
  toolNames: string[]
): { success: boolean; error?: string } {
  return runChatToResultSync(
    SettingsService.saveEnabledMcpTools(serverName, toolNames).pipe(
      Effect.as({})
    )
  )
}

export async function getEnabledMcpTools(): Promise<Record<string, string[]>> {
  return runChatPromiseOr(SettingsService.getEnabledMcpTools(), {})
}

export async function getEnabledMcpServersFromTools(): Promise<string[]> {
  return runChatPromiseOr(SettingsService.getEnabledMcpServersFromTools(), [])
}

export function getEnabledSkills(): string[] {
  return runChatSyncOr(SettingsService.getEnabledSkills(), [])
}

export function setSkillEnabled(
  name: string,
  enabled: boolean
): { success: boolean; error?: string } {
  return runChatToResultSync(
    SettingsService.setSkillEnabled(name, enabled).pipe(Effect.as({}))
  )
}

export function pruneEnabledSkillsTo(
  installedNames: readonly string[]
): number {
  return runChatSyncOr(SettingsService.pruneEnabledSkillsTo(installedNames), 0)
}

export function handleSaveSettings(
  providerId: string,
  settings:
    | { apiKey: string; enabledTools: string[] }
    | { endpointURL: string; enabledTools: string[] }
): { success: boolean; error?: string } {
  return runChatToResultSync(
    SettingsService.handleSaveSettings(providerId, settings).pipe(Effect.as({}))
  )
}

1	import { Effect } from 'effect'
2	import { runChatSyncOr, runChatPromiseOr, runChatToResultSync } from './runtime'
3	import { SettingsService } from './settings/settings-service'
4	import type {
5	ChatSettingsProvider,
6	ChatSettingsSelectedModel,
7	} from './settings/settings-service'
8	import {
9	CHAT_PROVIDER_INFO,
10	LOCAL_PROVIDER_IDS,
11	type LocalProviderId,
12	} from './constants'
13
14	type ProviderId = (typeof CHAT_PROVIDER_INFO)[number]['id']
15
16	function isLocalProvider(
17	providerId: ProviderId
18	): providerId is LocalProviderId {
NEW 19	return LOCAL_PROVIDER_IDS.includes(providerId as LocalProviderId)	×
20	}
21
22	function defaultChatSettings(providerId: ProviderId): ChatSettingsProvider {
UNCOV 23	if (isLocalProvider(providerId)) {	×
NEW 24	return { providerId, endpointURL: '', enabledTools: [] }	×
25	}
NEW 26	return {	×
27	providerId,
28	apiKey: '',
29	enabledTools: [],
30	}
31	}
32
33	const EMPTY_SELECTED_MODEL: ChatSettingsSelectedModel = {	12✔
34	provider: '',
35	model: '',
36	}
37
38	export function getChatSettings(providerId: ProviderId): ChatSettingsProvider {
NEW 39	return runChatSyncOr(	×
40	SettingsService.getChatSettings(providerId),
41	defaultChatSettings(providerId)
42	)
43	}
44
45	export function clearChatSettings(providerId?: ProviderId): {
46	success: boolean
47	error?: string
48	} {
NEW 49	return runChatToResultSync(	×
50	SettingsService.clearChatSettings(providerId).pipe(Effect.as({}))
51	)
52	}
53
54	export function getSelectedModel(): ChatSettingsSelectedModel {
NEW 55	return runChatSyncOr(SettingsService.getSelectedModel(), EMPTY_SELECTED_MODEL)	×
56	}
57
58	export function saveSelectedModel(
59	provider: string,
60	model: string
61	): { success: boolean; error?: string } {
NEW 62	return runChatToResultSync(	×
63	SettingsService.saveSelectedModel(provider, model).pipe(Effect.as({}))
64	)
65	}
66
67	export function saveEnabledMcpTools(
68	serverName: string,
69	toolNames: string[]
70	): { success: boolean; error?: string } {
NEW 71	return runChatToResultSync(	×
72	SettingsService.saveEnabledMcpTools(serverName, toolNames).pipe(
73	Effect.as({})
74	)
75	)
76	}
77
78	export async function getEnabledMcpTools(): Promise<Record<string, string[]>> {
NEW 79	return runChatPromiseOr(SettingsService.getEnabledMcpTools(), {})	×
80	}
81
82	export async function getEnabledMcpServersFromTools(): Promise<string[]> {
NEW 83	return runChatPromiseOr(SettingsService.getEnabledMcpServersFromTools(), [])	×
84	}
85
86	export function getEnabledSkills(): string[] {
NEW 87	return runChatSyncOr(SettingsService.getEnabledSkills(), [])	×
88	}
89
90	export function setSkillEnabled(
91	name: string,
92	enabled: boolean
93	): { success: boolean; error?: string } {
NEW 94	return runChatToResultSync(	×
95	SettingsService.setSkillEnabled(name, enabled).pipe(Effect.as({}))
96	)
97	}
98
99	export function pruneEnabledSkillsTo(
100	installedNames: readonly string[]
101	): number {
NEW 102	return runChatSyncOr(SettingsService.pruneEnabledSkillsTo(installedNames), 0)	×
103	}
104
105	export function handleSaveSettings(
106	providerId: string,
107	settings:
108	\| { apiKey: string; enabledTools: string[] }
109	\| { endpointURL: string; enabledTools: string[] }
110	): { success: boolean; error?: string } {
NEW 111	return runChatToResultSync(	×
112	SettingsService.handleSaveSettings(providerId, settings).pipe(Effect.as({}))
113	)
114	}

stacklok / toolhive-studio / 29571051485

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous