Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

13.8 KB
Raw Blame
import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'

import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { projectLogic } from 'scenes/projectLogic'

import { modelCatalogueLogic } from 'products/posthog_ai/frontend/logics/modelCatalogueLogic'
import { taskRunDefaultsLogic } from 'products/posthog_ai/frontend/logics/taskRunDefaultsLogic'
import { getRuntimeAdapterForModel } from 'products/posthog_ai/frontend/utils/composerModels'
import { tasksConfigCreate, tasksConfigList, tasksMeConfigCreate } from 'products/tasks/frontend/generated/api'
import { TaskRuntimeEnumApi } from 'products/tasks/frontend/generated/api.schemas'
import type {
    ModelChoiceApi,
    TasksAIRunPreferencesApi,
    TasksResolvedAIRunDefaultsApi,
    TasksUserConfigResponseApi,
} from 'products/tasks/frontend/generated/api.schemas'

/** A model/effort pick being edited in the settings UI; null model = inherit (no default stored). */
export interface AIRunPreferenceDraft {
    model: string | null
    reasoning_effort: string | null
}

const EMPTY_DRAFT: AIRunPreferenceDraft = { model: null, reasoning_effort: null }

interface DraftState {
    draft: AIRunPreferenceDraft
    touched: boolean
}

function isDraftChanged(draft: AIRunPreferenceDraft, stored: AIRunPreferenceDraft): boolean {
    return draft.model !== stored.model || draft.reasoning_effort !== stored.reasoning_effort
}

// A Pi default is authored in PostHog Desktop, and its models are not in this catalogue, so it
// cannot be edited here. Seeding it as empty keeps the editor on ACP, and any save made here
// moves the stored default to ACP rather than blocking the person.
function draftFromStored(stored: TasksAIRunPreferencesApi | null | undefined): AIRunPreferenceDraft {
    return stored?.model && stored.runtime !== TaskRuntimeEnumApi.Pi
        ? { model: stored.model, reasoning_effort: stored.reasoning_effort ?? null }
        : EMPTY_DRAFT
}

// The adapter is a property of the model, so it comes off the catalogue rather than the model id's
// spelling — the settings picker offers Codex models too, and a new harness must not be mislabelled.
function payloadFromDraft(draft: AIRunPreferenceDraft, catalogue: ModelChoiceApi[]): TasksAIRunPreferencesApi {
    if (!draft.model) {
        return { runtime: null, runtime_adapter: null, model: null, reasoning_effort: null }
    }
    return {
        runtime: TaskRuntimeEnumApi.Acp,
        runtime_adapter: getRuntimeAdapterForModel(catalogue, draft.model),
        model: draft.model,
        reasoning_effort: draft.reasoning_effort as TasksAIRunPreferencesApi['reasoning_effort'],
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface taskAgentDefaultsLogicValues {
    catalogue: ModelChoiceApi[] // modelCatalogueLogic
    currentProjectId: number | null // projectLogic
    myConfig: TasksUserConfigResponseApi | null // taskRunDefaultsLogic
    resolvedDefaults: TasksResolvedAIRunDefaultsApi | null // taskRunDefaultsLogic
    canResetMyPreference: boolean
    myDraft: AIRunPreferenceDraft
    myDraftDirty: boolean
    myDraftState: DraftState
    myPreferenceStored: AIRunPreferenceDraft
    myPreferences: TasksUserConfigResponseApi | null
    myPreferencesLoading: boolean
    myStoredPreferences: TasksAIRunPreferencesApi | null
    teamDraft: AIRunPreferenceDraft
    teamDraftDirty: boolean
    teamDraftState: DraftState
    teamPreferences: TasksAIRunPreferencesApi | null
    teamPreferencesLoading: boolean
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface taskAgentDefaultsLogicActions {
    loadMyConfig: () => any // taskRunDefaultsLogic
    loadMyConfigSuccess: (
        myConfig: TasksUserConfigResponseApi | null,
        payload?: any
    ) => {
        myConfig: TasksUserConfigResponseApi | null
        payload?: any
    } // taskRunDefaultsLogic
    loadTeamPreferences: () => any
    loadTeamPreferencesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadTeamPreferencesSuccess: (
        teamPreferences: TasksAIRunPreferencesApi | null,
        payload?: any
    ) => {
        teamPreferences: TasksAIRunPreferencesApi | null
        payload?: any
    }
    resetMyPreference: () => {
        value: true
    }
    saveMyPreferences: (preferences: TasksAIRunPreferencesApi) => TasksAIRunPreferencesApi
    saveMyPreferencesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    saveMyPreferencesSuccess: (
        myPreferences: TasksUserConfigResponseApi | null,
        payload?: TasksAIRunPreferencesApi
    ) => {
        myPreferences: TasksUserConfigResponseApi | null
        payload?: TasksAIRunPreferencesApi
    }
    saveTeamPreferences: (preferences: TasksAIRunPreferencesApi) => TasksAIRunPreferencesApi
    saveTeamPreferencesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    saveTeamPreferencesSuccess: (
        teamPreferences: TasksAIRunPreferencesApi | null,
        payload?: TasksAIRunPreferencesApi
    ) => {
        teamPreferences: TasksAIRunPreferencesApi | null
        payload?: TasksAIRunPreferencesApi
    }
    setMyDraft: (draft: Partial<AIRunPreferenceDraft>) => {
        draft: Partial<AIRunPreferenceDraft>
    }
    setTeamDraft: (draft: Partial<AIRunPreferenceDraft>) => {
        draft: Partial<AIRunPreferenceDraft>
    }
    submitMyDraft: () => {
        value: true
    }
    submitTeamDraft: () => {
        value: true
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface taskAgentDefaultsLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        teamDraft: (teamDraftState: DraftState) => AIRunPreferenceDraft
        myDraft: (myDraftState: DraftState) => AIRunPreferenceDraft
        myStoredPreferences: (
            myPreferences: TasksUserConfigResponseApi | null,
            myConfig: TasksUserConfigResponseApi | null
        ) => TasksAIRunPreferencesApi | null
        myPreferenceStored: (myStoredPreferences: TasksAIRunPreferencesApi | null) => AIRunPreferenceDraft
        teamDraftDirty: (teamDraft: AIRunPreferenceDraft, teamPreferences: TasksAIRunPreferencesApi | null) => boolean
        myDraftDirty: (myDraft: AIRunPreferenceDraft, myPreferenceStored: AIRunPreferenceDraft) => boolean
        canResetMyPreference: (
            myDraft: AIRunPreferenceDraft,
            myStoredPreferences: TasksAIRunPreferencesApi | null
        ) => boolean
    }
}

export type taskAgentDefaultsLogicType = MakeLogicType<
    taskAgentDefaultsLogicValues,
    taskAgentDefaultsLogicActions,
    Record<string, any>,
    taskAgentDefaultsLogicMeta
>

export const taskAgentDefaultsLogic = kea<taskAgentDefaultsLogicType>([
    path(['scenes', 'settings', 'environment', 'taskAgentDefaultsLogic']),

    connect(() => ({
        // `taskRunDefaultsLogic` already owns reading `@me/config` for the composers, and its
        // resolution is what this page is editing — sharing it keeps one cache and one fetch
        // instead of two that drift.
        values: [
            projectLogic,
            ['currentProjectId'],
            taskRunDefaultsLogic,
            ['myConfig', 'resolvedDefaults'],
            modelCatalogueLogic,
            ['catalogue'],
        ],
        actions: [taskRunDefaultsLogic, ['loadMyConfig', 'loadMyConfigSuccess']],
    })),

    actions({
        setTeamDraft: (draft: Partial<AIRunPreferenceDraft>) => ({ draft }),
        setMyDraft: (draft: Partial<AIRunPreferenceDraft>) => ({ draft }),
        submitTeamDraft: true,
        submitMyDraft: true,
        resetMyPreference: true,
    }),

    // Each card's draft carries a `touched` flag in the same reducer, so a load result can be
    // gated right where it lands: a refetch (the team save triggers one, and the shared
    // `myConfig` loader can resolve mid-edit) must never overwrite a pick someone is in the
    // middle of making. Saves untouch the draft — the stored value is the edit again.
    reducers({
        teamDraftState: [
            { draft: EMPTY_DRAFT, touched: false } as DraftState,
            {
                setTeamDraft: (state, { draft }) => ({ draft: { ...state.draft, ...draft }, touched: true }),
                loadTeamPreferencesSuccess: (state, { teamPreferences }) =>
                    state.touched ? state : { draft: draftFromStored(teamPreferences), touched: false },
                saveTeamPreferencesSuccess: (_, { teamPreferences }) => ({
                    draft: draftFromStored(teamPreferences),
                    touched: false,
                }),
            },
        ],
        myDraftState: [
            { draft: EMPTY_DRAFT, touched: false } as DraftState,
            {
                setMyDraft: (state, { draft }) => ({ draft: { ...state.draft, ...draft }, touched: true }),
                loadMyConfigSuccess: (state, { myConfig }) =>
                    state.touched ? state : { draft: draftFromStored(myConfig?.ai_run_preferences), touched: false },
                saveMyPreferencesSuccess: (_, { myPreferences }) => ({
                    draft: draftFromStored(myPreferences?.ai_run_preferences),
                    touched: false,
                }),
            },
        ],
    }),

    loaders(({ values }) => ({
        teamPreferences: {
            __default: null as TasksAIRunPreferencesApi | null,
            loadTeamPreferences: async (): Promise<TasksAIRunPreferencesApi | null> => {
                if (values.currentProjectId == null) {
                    return null
                }
                return (await tasksConfigList(String(values.currentProjectId))).ai_run_preferences
            },
            saveTeamPreferences: async (
                preferences: TasksAIRunPreferencesApi
            ): Promise<TasksAIRunPreferencesApi | null> => {
                const response = await tasksConfigCreate(String(values.currentProjectId), preferences)
                lemonToast.success(preferences.model ? 'Project default saved' : 'Project default cleared')
                return response.ai_run_preferences
            },
        },
        myPreferences: {
            __default: null as TasksUserConfigResponseApi | null,
            saveMyPreferences: async (
                preferences: TasksAIRunPreferencesApi
            ): Promise<TasksUserConfigResponseApi | null> => {
                const response = await tasksMeConfigCreate(String(values.currentProjectId), preferences)
                lemonToast.success(preferences.model ? 'Your default saved' : 'Reset to the project default')
                return response
            },
        },
    })),

    selectors({
        teamDraft: [(s) => [s.teamDraftState], (state: DraftState): AIRunPreferenceDraft => state.draft],
        myDraft: [(s) => [s.myDraftState], (state: DraftState): AIRunPreferenceDraft => state.draft],
        // The save response is read first so the reset button settles in the same tick as the
        // save; `myConfig` (refreshed alongside it) is what's there on mount and after a
        // project-level write.
        myStoredPreferences: [
            (s) => [s.myPreferences, s.myConfig],
            (
                saved: TasksUserConfigResponseApi | null,
                loaded: TasksUserConfigResponseApi | null
            ): TasksAIRunPreferencesApi | null => (saved ?? loaded)?.ai_run_preferences ?? null,
        ],
        myPreferenceStored: [
            (s) => [s.myStoredPreferences],
            (stored: TasksAIRunPreferencesApi | null): AIRunPreferenceDraft => draftFromStored(stored),
        ],
        // Whether there's anything to send.
        teamDraftDirty: [
            (s) => [s.teamDraft, s.teamPreferences],
            (draft: AIRunPreferenceDraft, stored: TasksAIRunPreferencesApi | null): boolean =>
                isDraftChanged(draft, draftFromStored(stored)),
        ],
        myDraftDirty: [
            (s) => [s.myDraft, s.myPreferenceStored],
            (draft: AIRunPreferenceDraft, stored: AIRunPreferenceDraft): boolean => isDraftChanged(draft, stored),
        ],
        // Nothing to fall back to when neither the draft nor the stored preference pins a model — the
        // effort alone is never stored without one.
        canResetMyPreference: [
            (s) => [s.myDraft, s.myStoredPreferences],
            (draft: AIRunPreferenceDraft, stored: TasksAIRunPreferencesApi | null): boolean =>
                Boolean(draft.model || stored?.model),
        ],
    }),

    listeners(({ actions, values }) => ({
        submitTeamDraft: () => {
            actions.saveTeamPreferences(payloadFromDraft(values.teamDraft, values.catalogue))
        },
        submitMyDraft: () => {
            actions.saveMyPreferences(payloadFromDraft(values.myDraft, values.catalogue))
        },
        // Clearing the stored preference is what hands the choice back to the project default, so the
        // reset discards any unsaved edit and saves the empty draft in one go.
        resetMyPreference: () => {
            actions.setMyDraft(EMPTY_DRAFT)
            actions.saveMyPreferences(payloadFromDraft(EMPTY_DRAFT, values.catalogue))
        },
        // Both writes change what an unpinned run resolves to, so the shared read the composers
        // render from has to move too. The team write can't say what the user-level answer
        // becomes, so it refetches; the personal write already has it in its own response.
        saveTeamPreferencesSuccess: () => {
            actions.loadMyConfig()
        },
        saveMyPreferencesSuccess: ({ myPreferences }) => {
            if (myPreferences) {
                actions.loadMyConfigSuccess(myPreferences)
            }
        },
    })),

    afterMount(({ actions }) => {
        actions.loadTeamPreferences()
    }),
])