Bohdan Triapitsyn
83ffb1af34
## What / Why This PR finishes the desktop refactor: the Tauri app is now a thin shell that launches the web server as a sidecar and loads the UI from `http://127.0.0.1:<port>`. All real backend logic lives in `packages/web/server/index.js`; desktop Rust keeps only native integrations (menu/dialog/notifications/updater/deep-link + window chrome). This unblocks: - consistent behavior across web/desktop/vscode (single backend) - simpler desktop maintenance (no duplicated Rust backend) - host switching between Local + remote instances in desktop - reliable cold-start behavior on slow machines (VSCode + desktop) ## Key changes - Desktop sidecar runtime - build pipeline to bundle web dist + `openchamber-server` sidecar (`packages/desktop/scripts/build-sidecar.mjs`) - robust local port selection (prefer saved/default, fallback to random; persisted in `~/.config/openchamber/settings.json`) - improved PATH handling so the sidecar can locate `opencode` CLI (incl `~/.opencode/bin`, overrides, common bins) - disable native right-click context menu in production builds (dev keeps it) - Desktop instance switcher (Tauri-only) - header button + modal to add/edit/delete remote hosts, set default, probe status/ping, switch back to Local escape hatch - auth gate includes host switcher so you can recover when a remote host is broken/auth-required - host list stored desktop-locally (not tied to the currently selected remote server) - Notifications - decision logic moved server-side; desktop notifications emitted via sidecar stdout and shown natively by Tauri - prevent double-notifications on desktop Local origin (UI ignores SSE notification when native path is active) - restore macOS notification sound - Updates - Tauri updater used only when viewing Local instance in desktop shell (avoid “remote web update” triggering desktop restart) - Settings persistence & UX polish - persist model favorites/recents via `/api/config/settings` (works for web + desktop; not origin-dependent) - persist per-project sidebar collapse state in `projects[].sidebarCollapsed` via `/api/config/settings` (with debounce on toggles) - macOS header sizing/traffic-lights offsets fixed (marketing macOS major injected from desktop; MultiRun header aligned) - VSCode cold-start: keep retrying provider/agent loads after connection to avoid empty UI on slow machines - misc lint/type fixes + bun.lock sync - Desktop bootstrap / resiliency - show onboarding screen when OpenCode CLI is missing (desktop Local origin), with retry hook to restart OpenCode after install ## Testing notes - Desktop (macOS): switch Local <-> remote, set default host, verify auth gate recovery, native notifications (with sound), updater gated to Local - Web: favorites/recents + per-project collapsed state persist across reload/restart - VSCode: slow startup no longer results in missing providers/agents/models
1449 lines
68 KiB
TypeScript
1449 lines
68 KiB
TypeScript
import { create } from "zustand";
|
|
import type { StoreApi, UseBoundStore } from "zustand";
|
|
import { devtools, persist, createJSONStorage } from "zustand/middleware";
|
|
import type { Provider, Agent } from "@opencode-ai/sdk/v2";
|
|
import { opencodeClient } from "@/lib/opencode/client";
|
|
import { scopeMatches, subscribeToConfigChanges } from "@/lib/configSync";
|
|
import type { ModelMetadata } from "@/types";
|
|
import { getSafeStorage } from "./utils/safeStorage";
|
|
import type { SessionStore } from "./types/sessionTypes";
|
|
import { filterVisibleAgents } from "./useAgentsStore";
|
|
import { getRegisteredRuntimeAPIs } from "@/contexts/runtimeAPIRegistry";
|
|
import { updateDesktopSettings } from "@/lib/persistence";
|
|
import { useDirectoryStore } from "@/stores/useDirectoryStore";
|
|
import { streamDebugEnabled } from "@/stores/utils/streamDebug";
|
|
|
|
const MODELS_DEV_API_URL = "https://models.dev/api.json";
|
|
const MODELS_DEV_PROXY_URL = "/api/openchamber/models-metadata";
|
|
|
|
const FALLBACK_PROVIDER_ID = "opencode";
|
|
const FALLBACK_MODEL_ID = "big-pickle";
|
|
|
|
interface OpenChamberDefaults {
|
|
defaultModel?: string;
|
|
defaultVariant?: string;
|
|
defaultAgent?: string;
|
|
autoCreateWorktree?: boolean;
|
|
gitmojiEnabled?: boolean;
|
|
}
|
|
|
|
const fetchOpenChamberDefaults = async (): Promise<OpenChamberDefaults> => {
|
|
try {
|
|
// 1. Runtime settings API (VSCode)
|
|
const runtimeSettings = getRegisteredRuntimeAPIs()?.settings;
|
|
if (runtimeSettings) {
|
|
try {
|
|
const result = await runtimeSettings.load();
|
|
const data = result?.settings;
|
|
if (data) {
|
|
const defaultModel = typeof data?.defaultModel === 'string' ? data.defaultModel.trim() : '';
|
|
const defaultVariant = typeof data?.defaultVariant === 'string' ? data.defaultVariant.trim() : '';
|
|
const defaultAgent = typeof data?.defaultAgent === 'string' ? data.defaultAgent.trim() : '';
|
|
const gitmojiEnabled = typeof data?.gitmojiEnabled === 'boolean' ? data.gitmojiEnabled : undefined;
|
|
|
|
return {
|
|
defaultModel: defaultModel.length > 0 ? defaultModel : undefined,
|
|
defaultVariant: defaultVariant.length > 0 ? defaultVariant : undefined,
|
|
defaultAgent: defaultAgent.length > 0 ? defaultAgent : undefined,
|
|
autoCreateWorktree: typeof data?.autoCreateWorktree === 'boolean' ? data.autoCreateWorktree : undefined,
|
|
gitmojiEnabled,
|
|
};
|
|
}
|
|
} catch {
|
|
// Fall through to fetch
|
|
}
|
|
}
|
|
|
|
// 2. Fetch API (Web/server)
|
|
const response = await fetch('/api/config/settings', {
|
|
method: 'GET',
|
|
headers: { Accept: 'application/json' },
|
|
});
|
|
if (!response.ok) {
|
|
return {};
|
|
}
|
|
const data = await response.json();
|
|
const defaultModel = typeof data?.defaultModel === 'string' ? data.defaultModel.trim() : '';
|
|
const defaultVariant = typeof data?.defaultVariant === 'string' ? data.defaultVariant.trim() : '';
|
|
const defaultAgent = typeof data?.defaultAgent === 'string' ? data.defaultAgent.trim() : '';
|
|
const gitmojiEnabled = typeof data?.gitmojiEnabled === 'boolean' ? data.gitmojiEnabled : undefined;
|
|
|
|
return {
|
|
defaultModel: defaultModel.length > 0 ? defaultModel : undefined,
|
|
defaultVariant: defaultVariant.length > 0 ? defaultVariant : undefined,
|
|
defaultAgent: defaultAgent.length > 0 ? defaultAgent : undefined,
|
|
autoCreateWorktree: typeof data?.autoCreateWorktree === 'boolean' ? data.autoCreateWorktree : undefined,
|
|
gitmojiEnabled,
|
|
};
|
|
} catch {
|
|
return {};
|
|
}
|
|
};
|
|
|
|
const parseModelString = (modelString: string): { providerId: string; modelId: string } | null => {
|
|
if (!modelString || typeof modelString !== 'string') {
|
|
return null;
|
|
}
|
|
const parts = modelString.split('/');
|
|
if (parts.length !== 2 || !parts[0] || !parts[1]) {
|
|
return null;
|
|
}
|
|
return { providerId: parts[0], modelId: parts[1] };
|
|
};
|
|
|
|
const normalizeProviderId = (value: string) => value?.toLowerCase?.() ?? '';
|
|
|
|
const isPrimaryMode = (mode?: string) => mode === "primary" || mode === "all" || mode === undefined || mode === null;
|
|
|
|
type ProviderModel = Provider["models"][string];
|
|
type ProviderWithModelList = Omit<Provider, "models"> & { models: ProviderModel[] };
|
|
|
|
interface ModelsDevModelEntry {
|
|
id?: string;
|
|
name?: string;
|
|
tool_call?: boolean;
|
|
reasoning?: boolean;
|
|
temperature?: boolean;
|
|
attachment?: boolean;
|
|
modalities?: {
|
|
input?: string[];
|
|
output?: string[];
|
|
};
|
|
cost?: {
|
|
input?: number;
|
|
output?: number;
|
|
cache_read?: number;
|
|
cache_write?: number;
|
|
};
|
|
limit?: {
|
|
context?: number;
|
|
output?: number;
|
|
};
|
|
knowledge?: string;
|
|
release_date?: string;
|
|
last_updated?: string;
|
|
}
|
|
|
|
interface ModelsDevProviderEntry {
|
|
id?: string;
|
|
models?: Record<string, ModelsDevModelEntry | undefined>;
|
|
}
|
|
|
|
const isRecord = (value: unknown): value is Record<string, unknown> =>
|
|
typeof value === "object" && value !== null;
|
|
|
|
const isStringArray = (value: unknown): value is string[] =>
|
|
Array.isArray(value) && value.every((item) => typeof item === "string");
|
|
|
|
const isModelsDevModelEntry = (value: unknown): value is ModelsDevModelEntry => {
|
|
if (!isRecord(value)) {
|
|
return false;
|
|
}
|
|
const candidate = value as ModelsDevModelEntry;
|
|
if (candidate.modalities) {
|
|
const { input, output } = candidate.modalities;
|
|
if (input && !isStringArray(input)) {
|
|
return false;
|
|
}
|
|
if (output && !isStringArray(output)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
const isModelsDevProviderEntry = (value: unknown): value is ModelsDevProviderEntry => {
|
|
if (!isRecord(value)) {
|
|
return false;
|
|
}
|
|
const candidate = value as ModelsDevProviderEntry;
|
|
return candidate.models === undefined || isRecord(candidate.models);
|
|
};
|
|
|
|
const buildModelMetadataKey = (providerId: string, modelId: string) => {
|
|
const normalizedProvider = normalizeProviderId(providerId);
|
|
if (!normalizedProvider || !modelId) {
|
|
return '';
|
|
}
|
|
return `${normalizedProvider}/${modelId}`;
|
|
};
|
|
|
|
const transformModelsDevResponse = (payload: unknown): Map<string, ModelMetadata> => {
|
|
const metadataMap = new Map<string, ModelMetadata>();
|
|
|
|
if (!isRecord(payload)) {
|
|
return metadataMap;
|
|
}
|
|
|
|
for (const [providerKey, providerValue] of Object.entries(payload)) {
|
|
if (!isModelsDevProviderEntry(providerValue)) {
|
|
continue;
|
|
}
|
|
|
|
const providerId = typeof providerValue.id === 'string' && providerValue.id.length > 0 ? providerValue.id : providerKey;
|
|
const models = providerValue.models;
|
|
if (!models || !isRecord(models)) {
|
|
continue;
|
|
}
|
|
|
|
for (const [modelKey, modelValue] of Object.entries(models)) {
|
|
if (!isModelsDevModelEntry(modelValue)) {
|
|
continue;
|
|
}
|
|
|
|
const resolvedModelId =
|
|
typeof modelKey === 'string' && modelKey.length > 0
|
|
? modelKey
|
|
: modelValue.id;
|
|
|
|
if (!resolvedModelId || typeof resolvedModelId !== 'string' || resolvedModelId.length === 0) {
|
|
continue;
|
|
}
|
|
|
|
const metadata: ModelMetadata = {
|
|
id: typeof modelValue.id === 'string' && modelValue.id.length > 0 ? modelValue.id : resolvedModelId,
|
|
providerId,
|
|
name: typeof modelValue.name === 'string' ? modelValue.name : undefined,
|
|
tool_call: typeof modelValue.tool_call === 'boolean' ? modelValue.tool_call : undefined,
|
|
reasoning: typeof modelValue.reasoning === 'boolean' ? modelValue.reasoning : undefined,
|
|
temperature: typeof modelValue.temperature === 'boolean' ? modelValue.temperature : undefined,
|
|
attachment: typeof modelValue.attachment === 'boolean' ? modelValue.attachment : undefined,
|
|
modalities: modelValue.modalities
|
|
? {
|
|
input: isStringArray(modelValue.modalities.input) ? modelValue.modalities.input : undefined,
|
|
output: isStringArray(modelValue.modalities.output) ? modelValue.modalities.output : undefined,
|
|
}
|
|
: undefined,
|
|
cost: modelValue.cost,
|
|
limit: modelValue.limit,
|
|
knowledge: typeof modelValue.knowledge === 'string' ? modelValue.knowledge : undefined,
|
|
release_date: typeof modelValue.release_date === 'string' ? modelValue.release_date : undefined,
|
|
last_updated: typeof modelValue.last_updated === 'string' ? modelValue.last_updated : undefined,
|
|
};
|
|
|
|
const key = buildModelMetadataKey(providerId, resolvedModelId);
|
|
if (key) {
|
|
metadataMap.set(key, metadata);
|
|
}
|
|
}
|
|
}
|
|
|
|
return metadataMap;
|
|
};
|
|
|
|
const fetchModelsDevMetadata = async (): Promise<Map<string, ModelMetadata>> => {
|
|
if (typeof fetch !== 'function') {
|
|
return new Map();
|
|
}
|
|
|
|
const sources = [MODELS_DEV_PROXY_URL, MODELS_DEV_API_URL];
|
|
|
|
for (const source of sources) {
|
|
const controller = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
|
|
const timeout = controller ? setTimeout(() => controller.abort(), 8000) : undefined;
|
|
|
|
try {
|
|
const isAbsoluteUrl = /^https?:\/\//i.test(source);
|
|
const requestInit: RequestInit = {
|
|
signal: controller?.signal,
|
|
headers: {
|
|
Accept: 'application/json',
|
|
},
|
|
cache: 'no-store',
|
|
};
|
|
|
|
if (isAbsoluteUrl) {
|
|
requestInit.mode = 'cors';
|
|
} else {
|
|
requestInit.credentials = 'same-origin';
|
|
}
|
|
|
|
const response = await fetch(source, requestInit);
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`Metadata request to ${source} returned status ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
return transformModelsDevResponse(data);
|
|
} catch (error: unknown) {
|
|
if ((error as Error)?.name === 'AbortError') {
|
|
console.warn(`Model metadata request aborted (${source})`);
|
|
} else {
|
|
console.warn(`Failed to fetch model metadata from ${source}:`, error);
|
|
}
|
|
} finally {
|
|
if (timeout) {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Map();
|
|
};
|
|
|
|
let modelsMetadataInFlight: Promise<Map<string, ModelMetadata>> | null = null;
|
|
|
|
const ensureModelsMetadataFetch = (
|
|
getModelsMetadata: () => Map<string, ModelMetadata>,
|
|
setModelsMetadata: (metadata: Map<string, ModelMetadata>) => void,
|
|
) => {
|
|
const existing = getModelsMetadata();
|
|
if (existing.size > 0) {
|
|
return;
|
|
}
|
|
|
|
if (modelsMetadataInFlight) {
|
|
return;
|
|
}
|
|
|
|
modelsMetadataInFlight = fetchModelsDevMetadata()
|
|
.then((metadata) => {
|
|
if (metadata.size > 0) {
|
|
setModelsMetadata(metadata);
|
|
}
|
|
return metadata;
|
|
})
|
|
.catch(() => new Map<string, ModelMetadata>())
|
|
.finally(() => {
|
|
modelsMetadataInFlight = null;
|
|
});
|
|
};
|
|
|
|
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
const DIRECTORY_KEY_GLOBAL = "__global__";
|
|
|
|
const toDirectoryKey = (directory: string | null | undefined): string => {
|
|
const trimmed = typeof directory === 'string' ? directory.trim() : '';
|
|
return trimmed.length > 0 ? trimmed : DIRECTORY_KEY_GLOBAL;
|
|
};
|
|
|
|
const fromDirectoryKey = (key: string): string | null => (key === DIRECTORY_KEY_GLOBAL ? null : key);
|
|
|
|
const resolveInitialDirectoryKey = (): string => {
|
|
if (typeof window === 'undefined') {
|
|
return DIRECTORY_KEY_GLOBAL;
|
|
}
|
|
|
|
const directory = opencodeClient.getDirectory() ?? useDirectoryStore.getState().currentDirectory;
|
|
return toDirectoryKey(directory);
|
|
};
|
|
|
|
interface DirectoryScopedConfig {
|
|
|
|
providers: ProviderWithModelList[];
|
|
agents: Agent[];
|
|
currentProviderId: string;
|
|
currentModelId: string;
|
|
currentVariant?: string | undefined;
|
|
currentAgentName: string | undefined;
|
|
selectedProviderId: string;
|
|
agentModelSelections: { [agentName: string]: { providerId: string; modelId: string } };
|
|
defaultProviders: { [key: string]: string };
|
|
}
|
|
|
|
interface ConfigStore {
|
|
|
|
activeDirectoryKey: string;
|
|
directoryScoped: Record<string, DirectoryScopedConfig>;
|
|
|
|
providers: ProviderWithModelList[];
|
|
agents: Agent[];
|
|
currentProviderId: string;
|
|
currentModelId: string;
|
|
currentVariant: string | undefined;
|
|
currentAgentName: string | undefined;
|
|
selectedProviderId: string;
|
|
agentModelSelections: { [agentName: string]: { providerId: string; modelId: string } };
|
|
defaultProviders: { [key: string]: string };
|
|
isConnected: boolean;
|
|
isInitialized: boolean;
|
|
modelsMetadata: Map<string, ModelMetadata>;
|
|
// OpenChamber settings-based defaults (take precedence over agent preferences)
|
|
settingsDefaultModel: string | undefined; // format: "provider/model"
|
|
settingsDefaultVariant: string | undefined;
|
|
settingsDefaultAgent: string | undefined;
|
|
settingsAutoCreateWorktree: boolean;
|
|
settingsGitmojiEnabled: boolean;
|
|
|
|
activateDirectory: (directory: string | null | undefined) => Promise<void>;
|
|
|
|
loadProviders: (options?: { directory?: string | null }) => Promise<void>;
|
|
loadAgents: (options?: { directory?: string | null }) => Promise<boolean>;
|
|
setProvider: (providerId: string) => void;
|
|
setModel: (modelId: string) => void;
|
|
setCurrentVariant: (variant: string | undefined) => void;
|
|
cycleCurrentVariant: () => void;
|
|
getCurrentModelVariants: () => string[];
|
|
setAgent: (agentName: string | undefined) => void;
|
|
setSelectedProvider: (providerId: string) => void;
|
|
setSettingsDefaultModel: (model: string | undefined) => void;
|
|
setSettingsDefaultVariant: (variant: string | undefined) => void;
|
|
setSettingsDefaultAgent: (agent: string | undefined) => void;
|
|
setSettingsAutoCreateWorktree: (enabled: boolean) => void;
|
|
setSettingsGitmojiEnabled: (enabled: boolean) => void;
|
|
saveAgentModelSelection: (agentName: string, providerId: string, modelId: string) => void;
|
|
getAgentModelSelection: (agentName: string) => { providerId: string; modelId: string } | null;
|
|
checkConnection: () => Promise<boolean>;
|
|
initializeApp: () => Promise<void>;
|
|
getCurrentProvider: () => ProviderWithModelList | undefined;
|
|
getCurrentModel: () => ProviderModel | undefined;
|
|
getCurrentAgent: () => Agent | undefined;
|
|
getModelMetadata: (providerId: string, modelId: string) => ModelMetadata | undefined;
|
|
// Returns only visible agents (excludes hidden internal agents like title, compaction, summary)
|
|
getVisibleAgents: () => Agent[];
|
|
}
|
|
|
|
declare global {
|
|
interface Window {
|
|
__zustand_config_store__?: UseBoundStore<StoreApi<ConfigStore>>;
|
|
__zustand_session_store__?: UseBoundStore<StoreApi<SessionStore>>;
|
|
}
|
|
}
|
|
|
|
export const useConfigStore = create<ConfigStore>()(
|
|
devtools(
|
|
persist(
|
|
(set, get) => ({
|
|
|
|
activeDirectoryKey: resolveInitialDirectoryKey(),
|
|
directoryScoped: {},
|
|
|
|
providers: [],
|
|
agents: [],
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentVariant: undefined,
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
isConnected: false,
|
|
isInitialized: false,
|
|
modelsMetadata: new Map<string, ModelMetadata>(),
|
|
settingsDefaultModel: undefined,
|
|
settingsDefaultVariant: undefined,
|
|
settingsDefaultAgent: undefined,
|
|
settingsAutoCreateWorktree: false,
|
|
settingsGitmojiEnabled: false,
|
|
|
|
activateDirectory: async (directory) => {
|
|
const directoryKey = toDirectoryKey(directory);
|
|
|
|
set((state) => {
|
|
const snapshot = state.directoryScoped[directoryKey];
|
|
if (snapshot) {
|
|
return {
|
|
activeDirectoryKey: directoryKey,
|
|
providers: snapshot.providers,
|
|
agents: snapshot.agents,
|
|
currentProviderId: snapshot.currentProviderId,
|
|
currentModelId: snapshot.currentModelId,
|
|
currentVariant: snapshot.currentVariant,
|
|
currentAgentName: snapshot.currentAgentName,
|
|
selectedProviderId: snapshot.selectedProviderId,
|
|
agentModelSelections: snapshot.agentModelSelections,
|
|
defaultProviders: snapshot.defaultProviders,
|
|
};
|
|
}
|
|
|
|
return {
|
|
activeDirectoryKey: directoryKey,
|
|
providers: [],
|
|
agents: [],
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
});
|
|
|
|
if (!get().isConnected) {
|
|
return;
|
|
}
|
|
|
|
await get().loadProviders({ directory: fromDirectoryKey(directoryKey) });
|
|
await get().loadAgents({ directory: fromDirectoryKey(directoryKey) });
|
|
},
|
|
|
|
loadProviders: async (options) => {
|
|
const directoryKey = toDirectoryKey(options?.directory ?? fromDirectoryKey(get().activeDirectoryKey));
|
|
const existingSnapshot = get().directoryScoped[directoryKey];
|
|
const previousProviders = existingSnapshot?.providers ?? (get().activeDirectoryKey === directoryKey ? get().providers : []);
|
|
const previousDefaults = existingSnapshot?.defaultProviders ?? (get().activeDirectoryKey === directoryKey ? get().defaultProviders : {});
|
|
let lastError: unknown = null;
|
|
|
|
for (let attempt = 0; attempt < 3; attempt++) {
|
|
try {
|
|
ensureModelsMetadataFetch(
|
|
() => get().modelsMetadata,
|
|
(metadata) => set({ modelsMetadata: metadata }),
|
|
);
|
|
const apiResult = await opencodeClient.withDirectory(
|
|
fromDirectoryKey(directoryKey),
|
|
() => opencodeClient.getProviders()
|
|
);
|
|
const providers = Array.isArray(apiResult?.providers) ? apiResult.providers : [];
|
|
const defaults = apiResult?.default || {};
|
|
|
|
const processedProviders: ProviderWithModelList[] = providers.map((provider) => {
|
|
const modelRecord = provider.models ?? {};
|
|
const models: ProviderModel[] = Object.keys(modelRecord).map((modelId) => modelRecord[modelId]);
|
|
return {
|
|
...provider,
|
|
models,
|
|
};
|
|
});
|
|
|
|
set((state) => {
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: [],
|
|
agents: [],
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
providers: processedProviders,
|
|
defaultProviders: defaults,
|
|
};
|
|
|
|
const nextState: Partial<ConfigStore> = {
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
|
|
if (state.activeDirectoryKey === directoryKey) {
|
|
nextState.providers = processedProviders;
|
|
nextState.defaultProviders = defaults;
|
|
|
|
if (!state.currentProviderId && !state.currentModelId && state.settingsDefaultModel) {
|
|
const parsed = parseModelString(state.settingsDefaultModel);
|
|
if (parsed) {
|
|
const settingsProvider = processedProviders.find((p) => p.id === parsed.providerId);
|
|
if (settingsProvider?.models.some((m) => m.id === parsed.modelId)) {
|
|
const model = settingsProvider.models.find((m) => m.id === parsed.modelId);
|
|
const currentVariant = state.settingsDefaultVariant && (model as { variants?: Record<string, unknown> } | undefined)?.variants?.[state.settingsDefaultVariant]
|
|
? state.settingsDefaultVariant
|
|
: undefined;
|
|
|
|
nextState.currentProviderId = parsed.providerId;
|
|
nextState.currentModelId = parsed.modelId;
|
|
nextState.currentVariant = currentVariant;
|
|
nextState.selectedProviderId = parsed.providerId;
|
|
|
|
nextSnapshot.currentProviderId = parsed.providerId;
|
|
nextSnapshot.currentModelId = parsed.modelId;
|
|
nextSnapshot.currentVariant = currentVariant;
|
|
nextSnapshot.selectedProviderId = parsed.providerId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nextState;
|
|
});
|
|
|
|
return;
|
|
} catch (error) {
|
|
lastError = error;
|
|
const waitMs = 200 * (attempt + 1);
|
|
await new Promise((resolve) => setTimeout(resolve, waitMs));
|
|
}
|
|
}
|
|
|
|
console.error("Failed to load providers:", lastError);
|
|
|
|
set((state) => {
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: [],
|
|
agents: [],
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
providers: previousProviders,
|
|
defaultProviders: previousDefaults,
|
|
};
|
|
|
|
const nextState: Partial<ConfigStore> = {
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
|
|
if (state.activeDirectoryKey === directoryKey) {
|
|
nextState.providers = previousProviders;
|
|
nextState.defaultProviders = previousDefaults;
|
|
|
|
if (!state.currentProviderId && !state.currentModelId && state.settingsDefaultModel) {
|
|
const parsed = parseModelString(state.settingsDefaultModel);
|
|
if (parsed) {
|
|
const settingsProvider = previousProviders.find((p) => p.id === parsed.providerId);
|
|
if (settingsProvider?.models.some((m) => m.id === parsed.modelId)) {
|
|
const model = settingsProvider.models.find((m) => m.id === parsed.modelId);
|
|
const currentVariant = state.settingsDefaultVariant && (model as { variants?: Record<string, unknown> } | undefined)?.variants?.[state.settingsDefaultVariant]
|
|
? state.settingsDefaultVariant
|
|
: undefined;
|
|
|
|
nextState.currentProviderId = parsed.providerId;
|
|
nextState.currentModelId = parsed.modelId;
|
|
nextState.currentVariant = currentVariant;
|
|
nextState.selectedProviderId = parsed.providerId;
|
|
|
|
nextSnapshot.currentProviderId = parsed.providerId;
|
|
nextSnapshot.currentModelId = parsed.modelId;
|
|
nextSnapshot.currentVariant = currentVariant;
|
|
nextSnapshot.selectedProviderId = parsed.providerId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nextState;
|
|
});
|
|
},
|
|
|
|
setProvider: (providerId: string) => {
|
|
const { providers } = get();
|
|
const provider = providers.find((p) => p.id === providerId);
|
|
|
|
if (!provider) {
|
|
return;
|
|
}
|
|
|
|
const firstModel = provider.models[0];
|
|
const newModelId = firstModel?.id || "";
|
|
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentVariant: state.currentVariant,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
currentProviderId: providerId,
|
|
currentModelId: newModelId,
|
|
selectedProviderId: providerId,
|
|
};
|
|
|
|
return {
|
|
currentProviderId: providerId,
|
|
currentModelId: newModelId,
|
|
selectedProviderId: providerId,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
},
|
|
|
|
setModel: (modelId: string) => {
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentVariant: state.currentVariant,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
currentModelId: modelId,
|
|
};
|
|
|
|
return {
|
|
currentModelId: modelId,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
},
|
|
|
|
setCurrentVariant: (variant: string | undefined) => {
|
|
set((state) => {
|
|
if (state.currentVariant === variant) {
|
|
return state;
|
|
}
|
|
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentVariant: state.currentVariant,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
currentVariant: variant,
|
|
};
|
|
|
|
return {
|
|
currentVariant: variant,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
},
|
|
|
|
getCurrentModelVariants: () => {
|
|
const model = get().getCurrentModel();
|
|
const variants = (model as { variants?: Record<string, unknown> } | undefined)?.variants;
|
|
if (!variants) {
|
|
return [];
|
|
}
|
|
return Object.keys(variants);
|
|
},
|
|
|
|
cycleCurrentVariant: () => {
|
|
const variantKeys = get().getCurrentModelVariants();
|
|
if (variantKeys.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const current = get().currentVariant;
|
|
if (!current) {
|
|
get().setCurrentVariant(variantKeys[0]);
|
|
return;
|
|
}
|
|
|
|
const index = variantKeys.indexOf(current);
|
|
if (index === -1 || index === variantKeys.length - 1) {
|
|
get().setCurrentVariant(undefined);
|
|
return;
|
|
}
|
|
|
|
get().setCurrentVariant(variantKeys[index + 1]);
|
|
},
|
|
|
|
setSelectedProvider: (providerId: string) => {
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
selectedProviderId: providerId,
|
|
};
|
|
|
|
return {
|
|
selectedProviderId: providerId,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
},
|
|
|
|
saveAgentModelSelection: (agentName: string, providerId: string, modelId: string) => {
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const nextSelections = {
|
|
...state.agentModelSelections,
|
|
[agentName]: { providerId, modelId },
|
|
};
|
|
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
agentModelSelections: nextSelections,
|
|
};
|
|
|
|
return {
|
|
agentModelSelections: nextSelections,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
},
|
|
|
|
getAgentModelSelection: (agentName: string) => {
|
|
const { agentModelSelections } = get();
|
|
return agentModelSelections[agentName] || null;
|
|
},
|
|
|
|
loadAgents: async (options) => {
|
|
const directoryKey = toDirectoryKey(options?.directory ?? fromDirectoryKey(get().activeDirectoryKey));
|
|
const existingSnapshot = get().directoryScoped[directoryKey];
|
|
const previousAgents = existingSnapshot?.agents ?? (get().activeDirectoryKey === directoryKey ? get().agents : []);
|
|
let lastError: unknown = null;
|
|
|
|
for (let attempt = 0; attempt < 3; attempt++) {
|
|
try {
|
|
// Fetch agents and OpenChamber settings in parallel
|
|
const [agents, openChamberDefaults] = await Promise.all([
|
|
opencodeClient.withDirectory(fromDirectoryKey(directoryKey), () => opencodeClient.listAgents()),
|
|
fetchOpenChamberDefaults(),
|
|
]);
|
|
|
|
const safeAgents = Array.isArray(agents) ? agents : [];
|
|
|
|
const providers = get().activeDirectoryKey === directoryKey
|
|
? get().providers
|
|
: (get().directoryScoped[directoryKey]?.providers ?? []);
|
|
|
|
set((state) => {
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers,
|
|
agents: previousAgents,
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
providers,
|
|
agents: safeAgents,
|
|
};
|
|
|
|
const nextState: Partial<ConfigStore> = {
|
|
settingsDefaultModel: openChamberDefaults.defaultModel,
|
|
settingsDefaultVariant: openChamberDefaults.defaultVariant,
|
|
settingsDefaultAgent: openChamberDefaults.defaultAgent,
|
|
settingsAutoCreateWorktree: openChamberDefaults.autoCreateWorktree ?? false,
|
|
settingsGitmojiEnabled: openChamberDefaults.gitmojiEnabled ?? false,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
|
|
if (state.activeDirectoryKey === directoryKey) {
|
|
nextState.agents = safeAgents;
|
|
}
|
|
|
|
return nextState;
|
|
});
|
|
|
|
if (safeAgents.length === 0) {
|
|
set((state) => {
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers,
|
|
agents: [],
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentVariant: undefined,
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
providers,
|
|
agents: [],
|
|
currentAgentName: undefined,
|
|
};
|
|
|
|
const nextState: Partial<ConfigStore> = {
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
|
|
if (state.activeDirectoryKey === directoryKey) {
|
|
nextState.currentAgentName = undefined;
|
|
}
|
|
|
|
return nextState;
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
// Helper to validate model exists in providers
|
|
const validateModel = (providerId: string, modelId: string): boolean => {
|
|
const provider = providers.find((p) => p.id === providerId);
|
|
if (!provider) return false;
|
|
return provider.models.some((m) => m.id === modelId);
|
|
};
|
|
|
|
// --- Agent Selection ---
|
|
// Priority: settings.defaultAgent → build → first primary → first agent
|
|
const primaryAgents = safeAgents.filter((agent) => isPrimaryMode(agent.mode));
|
|
const buildAgent = primaryAgents.find((agent) => agent.name === "build");
|
|
const fallbackAgent = buildAgent || primaryAgents[0] || safeAgents[0];
|
|
|
|
let resolvedAgent: Agent = fallbackAgent;
|
|
|
|
// Track invalid settings to clear
|
|
const invalidSettings: { defaultModel?: string; defaultVariant?: string; defaultAgent?: string } = {};
|
|
|
|
// 1. Check OpenChamber settings for default agent
|
|
if (openChamberDefaults.defaultAgent) {
|
|
const settingsAgent = safeAgents.find((agent) => agent.name === openChamberDefaults.defaultAgent);
|
|
if (settingsAgent) {
|
|
resolvedAgent = settingsAgent;
|
|
} else {
|
|
// Agent no longer exists - mark for clearing
|
|
invalidSettings.defaultAgent = '';
|
|
}
|
|
}
|
|
|
|
// --- Model Selection ---
|
|
// Priority: settings.defaultModel → agent's preferred model → opencode/big-pickle
|
|
let resolvedProviderId: string | undefined;
|
|
let resolvedModelId: string | undefined;
|
|
let resolvedVariant: string | undefined;
|
|
|
|
// 1. Check OpenChamber settings for default model
|
|
if (openChamberDefaults.defaultModel) {
|
|
const parsed = parseModelString(openChamberDefaults.defaultModel);
|
|
if (parsed && validateModel(parsed.providerId, parsed.modelId)) {
|
|
resolvedProviderId = parsed.providerId;
|
|
resolvedModelId = parsed.modelId;
|
|
|
|
if (openChamberDefaults.defaultVariant) {
|
|
const provider = providers.find((p) => p.id === parsed.providerId);
|
|
const model = provider?.models.find((m) => m.id === parsed.modelId) as { variants?: Record<string, unknown> } | undefined;
|
|
const variants = model?.variants;
|
|
if (variants && Object.prototype.hasOwnProperty.call(variants, openChamberDefaults.defaultVariant)) {
|
|
resolvedVariant = openChamberDefaults.defaultVariant;
|
|
} else {
|
|
invalidSettings.defaultVariant = '';
|
|
}
|
|
}
|
|
} else {
|
|
// Model no longer exists - mark for clearing
|
|
invalidSettings.defaultModel = '';
|
|
}
|
|
}
|
|
|
|
// 2. Fall back to agent's preferred model
|
|
if (!resolvedProviderId && resolvedAgent?.model?.providerID && resolvedAgent?.model?.modelID) {
|
|
const { providerID, modelID } = resolvedAgent.model;
|
|
if (validateModel(providerID, modelID)) {
|
|
resolvedProviderId = providerID;
|
|
resolvedModelId = modelID;
|
|
}
|
|
}
|
|
|
|
// 3. Fall back to opencode/big-pickle
|
|
if (!resolvedProviderId) {
|
|
if (validateModel(FALLBACK_PROVIDER_ID, FALLBACK_MODEL_ID)) {
|
|
resolvedProviderId = FALLBACK_PROVIDER_ID;
|
|
resolvedModelId = FALLBACK_MODEL_ID;
|
|
} else {
|
|
// Last resort: first provider's first model
|
|
const firstProvider = providers[0];
|
|
const firstModel = firstProvider?.models[0];
|
|
if (firstProvider && firstModel) {
|
|
resolvedProviderId = firstProvider.id;
|
|
resolvedModelId = firstModel.id;
|
|
}
|
|
}
|
|
}
|
|
|
|
set((state) => {
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers,
|
|
agents: safeAgents,
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
providers,
|
|
agents: safeAgents,
|
|
currentAgentName: resolvedAgent.name,
|
|
currentProviderId: resolvedProviderId ?? baseSnapshot.currentProviderId,
|
|
currentModelId: resolvedModelId ?? baseSnapshot.currentModelId,
|
|
currentVariant: resolvedVariant,
|
|
};
|
|
|
|
const nextState: Partial<ConfigStore> = {
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
|
|
if (state.activeDirectoryKey === directoryKey) {
|
|
nextState.currentAgentName = resolvedAgent.name;
|
|
if (resolvedProviderId && resolvedModelId) {
|
|
nextState.currentProviderId = resolvedProviderId;
|
|
nextState.currentModelId = resolvedModelId;
|
|
nextState.currentVariant = resolvedVariant;
|
|
}
|
|
}
|
|
|
|
return nextState;
|
|
});
|
|
|
|
// Clear invalid settings from storage (best-effort cleanup)
|
|
if (Object.keys(invalidSettings).length > 0) {
|
|
// Also clear from store state
|
|
set({
|
|
settingsDefaultModel: invalidSettings.defaultModel !== undefined ? undefined : get().settingsDefaultModel,
|
|
settingsDefaultVariant: invalidSettings.defaultVariant !== undefined ? undefined : get().settingsDefaultVariant,
|
|
settingsDefaultAgent: invalidSettings.defaultAgent !== undefined ? undefined : get().settingsDefaultAgent,
|
|
});
|
|
updateDesktopSettings(invalidSettings).catch(() => {
|
|
// Ignore errors - best effort cleanup
|
|
});
|
|
}
|
|
|
|
return true;
|
|
} catch (error) {
|
|
lastError = error;
|
|
const waitMs = 200 * (attempt + 1);
|
|
await new Promise((resolve) => setTimeout(resolve, waitMs));
|
|
}
|
|
}
|
|
|
|
console.error("Failed to load agents:", lastError);
|
|
|
|
set((state) => {
|
|
const providers = state.activeDirectoryKey === directoryKey
|
|
? state.providers
|
|
: (state.directoryScoped[directoryKey]?.providers ?? []);
|
|
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers,
|
|
agents: [],
|
|
currentProviderId: "",
|
|
currentModelId: "",
|
|
currentAgentName: undefined,
|
|
selectedProviderId: "",
|
|
agentModelSelections: {},
|
|
defaultProviders: {},
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
providers,
|
|
agents: previousAgents,
|
|
};
|
|
|
|
const nextState: Partial<ConfigStore> = {
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
|
|
if (state.activeDirectoryKey === directoryKey) {
|
|
nextState.agents = previousAgents;
|
|
}
|
|
|
|
return nextState;
|
|
});
|
|
|
|
return false;
|
|
},
|
|
|
|
setAgent: (agentName: string | undefined) => {
|
|
const { agents, providers, settingsDefaultModel, settingsDefaultVariant } = get();
|
|
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
currentAgentName: agentName,
|
|
};
|
|
|
|
return {
|
|
currentAgentName: agentName,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
|
|
if (agentName && typeof window !== "undefined") {
|
|
|
|
const sessionStore = window.__zustand_session_store__;
|
|
if (sessionStore) {
|
|
const sessionState = sessionStore.getState();
|
|
const { currentSessionId, isOpenChamberCreatedSession, initializeNewOpenChamberSession, getAgentModelForSession } = sessionState;
|
|
|
|
if (currentSessionId) {
|
|
|
|
sessionStore.setState((state) => {
|
|
const newAgentContext = new Map(state.currentAgentContext);
|
|
newAgentContext.set(currentSessionId, agentName);
|
|
return { currentAgentContext: newAgentContext };
|
|
});
|
|
}
|
|
|
|
if (currentSessionId && isOpenChamberCreatedSession(currentSessionId)) {
|
|
const existingAgentModel = getAgentModelForSession(currentSessionId, agentName);
|
|
if (!existingAgentModel) {
|
|
|
|
initializeNewOpenChamberSession(currentSessionId, agents);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (agentName && typeof window !== "undefined") {
|
|
const sessionStore = window.__zustand_session_store__;
|
|
if (sessionStore?.getState) {
|
|
const { currentSessionId, getAgentModelForSession } = sessionStore.getState();
|
|
|
|
if (currentSessionId) {
|
|
const existingAgentModel = getAgentModelForSession(currentSessionId, agentName);
|
|
|
|
if (existingAgentModel) {
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If settings has a default model, use it instead of agent's preferred
|
|
if (settingsDefaultModel) {
|
|
const parsed = parseModelString(settingsDefaultModel);
|
|
if (parsed) {
|
|
const settingsProvider = providers.find((p) => p.id === parsed.providerId);
|
|
if (settingsProvider?.models.some((m) => m.id === parsed.modelId)) {
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentVariant: state.currentVariant,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
let nextVariant: string | undefined;
|
|
if (settingsDefaultVariant) {
|
|
const settingsProvider = providers.find((p) => p.id === parsed.providerId);
|
|
const model = settingsProvider?.models.find((m) => m.id === parsed.modelId) as { variants?: Record<string, unknown> } | undefined;
|
|
const variants = model?.variants;
|
|
if (variants && Object.prototype.hasOwnProperty.call(variants, settingsDefaultVariant)) {
|
|
nextVariant = settingsDefaultVariant;
|
|
}
|
|
}
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
currentProviderId: parsed.providerId,
|
|
currentModelId: parsed.modelId,
|
|
currentVariant: nextVariant,
|
|
};
|
|
|
|
return {
|
|
currentProviderId: parsed.providerId,
|
|
currentModelId: parsed.modelId,
|
|
currentVariant: nextVariant,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fall back to agent's preferred model
|
|
const agent = agents.find((candidate) => candidate.name === agentName);
|
|
const agentModelSelection = agent?.model;
|
|
if (agentModelSelection?.providerID && agentModelSelection?.modelID) {
|
|
const { providerID, modelID } = agentModelSelection;
|
|
const agentProvider = providers.find((provider) => provider.id === providerID);
|
|
const agentModel = agentProvider?.models.find((model) => model.id === modelID);
|
|
|
|
if (agentModel) {
|
|
set((state) => {
|
|
const directoryKey = state.activeDirectoryKey;
|
|
const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
|
|
providers: state.providers,
|
|
agents: state.agents,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
};
|
|
|
|
const nextSnapshot: DirectoryScopedConfig = {
|
|
...baseSnapshot,
|
|
currentProviderId: providerID,
|
|
currentModelId: modelID,
|
|
selectedProviderId: providerID,
|
|
};
|
|
|
|
return {
|
|
currentProviderId: providerID,
|
|
currentModelId: modelID,
|
|
selectedProviderId: providerID,
|
|
directoryScoped: {
|
|
...state.directoryScoped,
|
|
[directoryKey]: nextSnapshot,
|
|
},
|
|
};
|
|
});
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
setSettingsDefaultModel: (model: string | undefined) => {
|
|
set({ settingsDefaultModel: model });
|
|
},
|
|
|
|
setSettingsDefaultVariant: (variant: string | undefined) => {
|
|
set({ settingsDefaultVariant: variant });
|
|
},
|
|
|
|
setSettingsDefaultAgent: (agent: string | undefined) => {
|
|
set({ settingsDefaultAgent: agent });
|
|
},
|
|
|
|
setSettingsAutoCreateWorktree: (enabled: boolean) => {
|
|
set({ settingsAutoCreateWorktree: enabled });
|
|
},
|
|
|
|
setSettingsGitmojiEnabled: (enabled: boolean) => {
|
|
set({ settingsGitmojiEnabled: enabled });
|
|
},
|
|
|
|
checkConnection: async () => {
|
|
const maxAttempts = 5;
|
|
let attempt = 0;
|
|
let lastError: unknown = null;
|
|
|
|
while (attempt < maxAttempts) {
|
|
try {
|
|
const isHealthy = await opencodeClient.checkHealth();
|
|
set({ isConnected: isHealthy });
|
|
return isHealthy;
|
|
} catch (error) {
|
|
lastError = error;
|
|
attempt += 1;
|
|
const delay = 400 * attempt;
|
|
await sleep(delay);
|
|
}
|
|
}
|
|
|
|
if (lastError) {
|
|
console.warn("[ConfigStore] Failed to reach OpenCode after retrying:", lastError);
|
|
}
|
|
set({ isConnected: false });
|
|
return false;
|
|
},
|
|
|
|
initializeApp: async () => {
|
|
try {
|
|
const debug = streamDebugEnabled();
|
|
if (debug) console.log("Starting app initialization...");
|
|
|
|
const isConnected = await get().checkConnection();
|
|
if (debug) console.log("Connection check result:", isConnected);
|
|
|
|
if (!isConnected) {
|
|
if (debug) console.log("Server not connected");
|
|
set({ isConnected: false });
|
|
return;
|
|
}
|
|
|
|
if (debug) console.log("Initializing app...");
|
|
await opencodeClient.initApp();
|
|
|
|
if (debug) console.log("Loading providers...");
|
|
await get().loadProviders();
|
|
|
|
if (debug) console.log("Loading agents...");
|
|
await get().loadAgents();
|
|
|
|
set({ isInitialized: true, isConnected: true });
|
|
if (debug) console.log("App initialized successfully");
|
|
} catch (error) {
|
|
console.error("Failed to initialize app:", error);
|
|
set({ isInitialized: false, isConnected: false });
|
|
}
|
|
},
|
|
|
|
getCurrentProvider: () => {
|
|
const { providers, currentProviderId } = get();
|
|
return providers.find((p) => p.id === currentProviderId);
|
|
},
|
|
|
|
getCurrentModel: () => {
|
|
const provider = get().getCurrentProvider();
|
|
const { currentModelId } = get();
|
|
if (!provider) {
|
|
return undefined;
|
|
}
|
|
return provider.models.find((model) => model.id === currentModelId);
|
|
},
|
|
|
|
getCurrentAgent: () => {
|
|
const { agents, currentAgentName } = get();
|
|
if (!currentAgentName) return undefined;
|
|
return agents.find((a) => a.name === currentAgentName);
|
|
},
|
|
getModelMetadata: (providerId: string, modelId: string) => {
|
|
const key = buildModelMetadataKey(providerId, modelId);
|
|
if (!key) {
|
|
return undefined;
|
|
}
|
|
const { modelsMetadata } = get();
|
|
return modelsMetadata.get(key);
|
|
},
|
|
getVisibleAgents: () => {
|
|
const { agents } = get();
|
|
return filterVisibleAgents(agents);
|
|
},
|
|
}),
|
|
{
|
|
name: "config-store",
|
|
storage: createJSONStorage(() => getSafeStorage()),
|
|
partialize: (state) => ({
|
|
activeDirectoryKey: state.activeDirectoryKey,
|
|
directoryScoped: state.directoryScoped,
|
|
currentProviderId: state.currentProviderId,
|
|
currentModelId: state.currentModelId,
|
|
currentVariant: state.currentVariant,
|
|
currentAgentName: state.currentAgentName,
|
|
selectedProviderId: state.selectedProviderId,
|
|
agentModelSelections: state.agentModelSelections,
|
|
defaultProviders: state.defaultProviders,
|
|
settingsDefaultModel: state.settingsDefaultModel,
|
|
settingsDefaultVariant: state.settingsDefaultVariant,
|
|
settingsDefaultAgent: state.settingsDefaultAgent,
|
|
settingsAutoCreateWorktree: state.settingsAutoCreateWorktree,
|
|
settingsGitmojiEnabled: state.settingsGitmojiEnabled,
|
|
}),
|
|
},
|
|
),
|
|
),
|
|
);
|
|
|
|
if (typeof window !== "undefined") {
|
|
window.__zustand_config_store__ = useConfigStore;
|
|
}
|
|
|
|
let unsubscribeConfigStoreChanges: (() => void) | null = null;
|
|
|
|
if (!unsubscribeConfigStoreChanges) {
|
|
unsubscribeConfigStoreChanges = subscribeToConfigChanges(async (event) => {
|
|
const tasks: Promise<void>[] = [];
|
|
|
|
if (scopeMatches(event, "agents")) {
|
|
const { loadAgents } = useConfigStore.getState();
|
|
tasks.push(loadAgents().then(() => {}));
|
|
}
|
|
|
|
if (scopeMatches(event, "providers")) {
|
|
const { loadProviders } = useConfigStore.getState();
|
|
tasks.push(loadProviders());
|
|
}
|
|
|
|
if (tasks.length > 0) {
|
|
await Promise.all(tasks);
|
|
}
|
|
});
|
|
}
|
|
|
|
let unsubscribeConfigStoreDirectoryChanges: (() => void) | null = null;
|
|
|
|
if (typeof window !== "undefined" && !unsubscribeConfigStoreDirectoryChanges) {
|
|
unsubscribeConfigStoreDirectoryChanges = useDirectoryStore.subscribe((state, prevState) => {
|
|
const nextKey = toDirectoryKey(state.currentDirectory);
|
|
const prevKey = toDirectoryKey(prevState.currentDirectory);
|
|
if (nextKey === prevKey) {
|
|
return;
|
|
}
|
|
|
|
void useConfigStore.getState().activateDirectory(state.currentDirectory);
|
|
});
|
|
}
|