Ask,
Don't Query.

def resolve_context(message: str, state: SessionState) -> ResolvedContext:
    """Pure Python - no LLM calls."""
    fqn = extract_fqn(message)
    if fqn:
        return ResolvedContext(fqn=fqn, source=ContextSource.EXPLICIT)

    position = extract_position_reference(message)
    if position and state.last_search_results:
        if 1 <= position <= len(state.last_search_results):
            result = state.last_search_results[position - 1]
            return ResolvedContext(fqn=result.fqn, source=ContextSource.POSITION)
        raise ContextError(f"No result at position {position}")

    if has_pronoun_reference(message) and state.focus:
        return ResolvedContext(fqn=state.focus.fqn, source=ContextSource.PRONOUN)

    if references_last_chart(message) and state.last_chart_fqn:
        return ResolvedContext(fqn=state.last_chart_fqn, source=ContextSource.LAST_CHART)

    return ResolvedContext(fqn=None, source=ContextSource.NONE)

def validate_filters(filters, schema):
    vocab_map = schema.get("vocab_map", {})
    normalized_filters = {}
    errors = []

    for column, values in filters.items():
        if column not in vocab_map:
            normalized_filters[column] = values
            continue

        valid_lower_to_original_map = {v.lower(): v for v in vocab_map[column]}
        resolved_values = []
        for value in values:
            if value.lower() in valid_lower_to_original_map:
                resolved_values.append(valid_lower_to_original_map[value.lower()])
            else:
                errors.append(
                    f"Value '{value}' is not valid for column '{column}'. "
                    f"Valid options include: {', '.join(vocab_map[column][:5])}..."
                )
        normalized_filters[column] = resolved_values

    if errors:
        raise ValidationError(errors)
    return normalized_filters

def _slim_candidate(candidate):
    if candidate.get("type") != "dataset":
        return {"fqn": candidate["fqn"], "name": candidate["name"], "type": candidate["type"]}
    return {
        "fqn": candidate["fqn"],
        "name": candidate["name"],
        "type": candidate["type"],
        "table_name": candidate.get("table_name", ""),
        "main_dttm_col": candidate.get("main_dttm_col", ""),
        "columns": [
            {"column_name": c["column_name"], "description": c.get("description", "")}
            for c in candidate.get("columns", [])
        ],
        "metrics": [{"metric_name": m["metric_name"]} for m in candidate.get("metrics", [])],
    }

def _build_time_where_clause(time_requirements, main_dttm_col):
    if not time_requirements:
        return ""
    if time_requirements.type == "relative":
        value = time_requirements.value
        if value == "last_month":
            return f"{main_dttm_col} >= DATE_TRUNC('month', CURRENT_DATE - INTERVAL '1 month') AND {main_dttm_col} < DATE_TRUNC('month', CURRENT_DATE)"
        elif value == "yesterday":
            return f"{main_dttm_col} >= CURRENT_DATE - INTERVAL '1 day' AND {main_dttm_col} < CURRENT_DATE"
    elif time_requirements.type == "quarter":
        q, y = time_requirements.quarter, time_requirements.year
        start = f"{y}-{3*q-2:02d}-01"
        end = f"{y+1}-01-01" if q == 4 else f"{y}-{3*q+1:02d}-01"
        return f"{main_dttm_col} >= '{start}' AND {main_dttm_col} < '{end}'"

async def dispatch(message: str, history: List[Message]) -> str:
    instructions = Path(__file__).with_name("prompt.md").read_text()
    history_text = "\n".join(f"{m.role}: {m.content}" for m in history[-10:])
    model_name = os.getenv("SUPERSET_DISPATCHER_MODEL")
    llm = ChatOpenAI(model=model_name, temperature=0, response_format={"type": "json_object"})
    response = await llm.ainvoke([
        SystemMessage(content=f"{instructions}\n\nConversation history:\n{history_text}"),
        HumanMessage(content=message),
    ])
    return json.loads(response.content)["intent"]

def find_candidates(message: str, resolved_fqn: str | None) -> List[Dict]:
    if resolved_fqn:
        asset = load_asset_by_fqn(resolved_fqn)
        if asset:
            return [asset]
        raise AssetNotFoundError(resolved_fqn)
    return faiss_search(message, top_k=3)

@dataclass
class SessionState:
    conversation_id: str
    history: List[Message]
    focus: Optional[Focus] = None
    last_search_results: Optional[List[SearchResult]] = None  # For "the 2nd one"
    last_chart_fqn: Optional[str] = None                      # For "update that chart"

@dataclass
class PlannerResponse:
    sub_intent: str
    asset_fqn: str
    asset_type: str
    reasoning: str
    dimensions: Optional[List[str]] = None
    metrics: Optional[List[str]] = None
    filters: Optional[Dict[str, List[str]]] = None
    time_requirements: Optional[TimeRequirements] = None
    viz_hint: Optional[str] = None
    chart_title: Optional[str] = None
    limit: Optional[int] = None