flowent 0.1.5 → 0.2.1

package/backend/tests/test_llm_providers.py

@@ -1,387 +0,0 @@
-import json
-
-import pytest
-
-from flowent.llm import (
-    ChatMessage,
-    ProviderConnection,
-    ProviderFormat,
-    ReasoningEffort,
-    build_litellm_request,
-    chunk_delta_reasoning,
-    complete_chat,
-    normalize_system_messages,
-    stream_chat,
-)
-
-
-def read_single_llm_request_diagnostic(tmp_path):
-    files = sorted((tmp_path / "logs" / "llm-requests").glob("llm-request-*.json"))
-    assert len(files) == 1
-    return json.loads(files[0].read_text())
-
-
-def test_supported_provider_formats_match_product_choices() -> None:
-    assert [provider.value for provider in ProviderFormat] == [
-        "openai",
-        "openai_responses",
-        "anthropic",
-        "gemini",
-    ]
-
-
-def test_build_litellm_request_maps_provider_connection_to_completion_args() -> None:
-    connection = ProviderConnection(
-        name="Primary",
-        provider=ProviderFormat.ANTHROPIC,
-        model="claude-sonnet-4-5",
-        secret_reference="connection-primary",
-        base_url="https://example.test/v1",
-    )
-    messages = [
-        ChatMessage(role="system", content="Keep answers direct."),
-        ChatMessage(role="user", content="Draft a launch checklist."),
-    ]
-
-    request = build_litellm_request(connection, messages)
-
-    assert request == {
-        "api_base": "https://example.test/v1",
-        "api_key": "connection-primary",
-        "messages": [
-            {"role": "system", "content": "Keep answers direct."},
-            {"role": "user", "content": "Draft a launch checklist."},
-        ],
-        "model": "anthropic/claude-sonnet-4-5",
-    }
-
-
-def test_build_litellm_request_omits_default_reasoning_effort() -> None:
-    connection = ProviderConnection(
-        name="Primary",
-        provider=ProviderFormat.OPENAI,
-        model="gpt-5.1",
-        secret_reference="connection-primary",
-        reasoning_effort=ReasoningEffort.DEFAULT,
-    )
-
-    request = build_litellm_request(
-        connection, [ChatMessage(role="user", content="Draft a checklist.")]
-    )
-
-    assert "reasoning_effort" not in request
-
-
-def test_build_litellm_request_includes_selected_reasoning_effort() -> None:
-    connection = ProviderConnection(
-        name="Primary",
-        provider=ProviderFormat.OPENAI,
-        model="gpt-5.1",
-        secret_reference="connection-primary",
-        reasoning_effort=ReasoningEffort.XHIGH,
-    )
-
-    request = build_litellm_request(
-        connection, [ChatMessage(role="user", content="Draft a checklist.")]
-    )
-
-    assert request["reasoning_effort"] == "xhigh"
-
-
-def test_chunk_delta_reasoning_reads_litellm_reasoning_fields() -> None:
-    assert (
-        chunk_delta_reasoning(
-            {"choices": [{"delta": {"reasoning_content": "Checking files."}}]}
-        )
-        == "Checking files."
-    )
-    assert (
-        chunk_delta_reasoning(
-            {
-                "choices": [
-                    {
-                        "delta": {
-                            "thinking_blocks": [{"thinking": "Read files."}],
-                            "reasoning_items": [{"summary": "Summarize."}],
-                        }
-                    }
-                ]
-            }
-        )
-        == "Read files.Summarize."
-    )
-
-
-@pytest.mark.anyio
-async def test_complete_chat_uses_injected_litellm_completion() -> None:
-    captured_request: dict[str, object] = {}
-
-    async def fake_completion(**request: object) -> dict[str, object]:
-        captured_request.update(request)
-        return {
-            "choices": [
-                {
-                    "message": {
-                        "content": "Here is the checklist.",
-                        "role": "assistant",
-                    },
-                }
-            ]
-        }
-
-    connection = ProviderConnection(
-        name="Responses",
-        provider=ProviderFormat.OPENAI_RESPONSES,
-        model="gpt-5.1",
-        secret_reference="connection-responses",
-    )
-
-    answer = await complete_chat(
-        connection,
-        [ChatMessage(role="user", content="Create a checklist.")],
-        completion=fake_completion,
-    )
-
-    assert captured_request["model"] == "openai/gpt-5.1"
-    assert answer == ChatMessage(role="assistant", content="Here is the checklist.")
-
-
-@pytest.mark.anyio
-async def test_development_mode_writes_completion_request_diagnostic_file(
-    tmp_path, monkeypatch
-) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    monkeypatch.setenv("DEBUG", "true")
-
-    async def fake_completion(**request: object) -> dict[str, object]:
-        return {
-            "choices": [
-                {
-                    "message": {
-                        "content": "Here is the checklist.",
-                        "role": "assistant",
-                    },
-                }
-            ]
-        }
-
-    connection = ProviderConnection(
-        name="Responses",
-        provider=ProviderFormat.OPENAI_RESPONSES,
-        model="gpt-5.1",
-        secret_reference="sk-request-secret",
-    )
-    messages = [ChatMessage(role="user", content="Create a checklist.")]
-    tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "create_checklist",
-                "description": "Create a checklist.",
-            },
-        }
-    ]
-
-    await complete_chat(
-        connection,
-        messages,
-        completion=fake_completion,
-        tools=tools,
-    )
-
-    diagnostic = read_single_llm_request_diagnostic(tmp_path)
-
-    assert diagnostic == {
-        "base_url": None,
-        "litellm_model": "openai/gpt-5.1",
-        "messages": [{"content": "Create a checklist.", "role": "user"}],
-        "model": "gpt-5.1",
-        "provider": "openai_responses",
-        "reasoning_effort": "default",
-        "stream": False,
-        "tools": tools,
-    }
-
-
-@pytest.mark.anyio
-async def test_stream_chat_uses_litellm_streaming() -> None:
-    captured_request: dict[str, object] = {}
-
-    async def fake_completion(**request: object) -> object:
-        captured_request.update(request)
-
-        async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Here is "}}]}
-            yield {"choices": [{"delta": {"content": "the checklist."}}]}
-
-        return chunks()
-
-    connection = ProviderConnection(
-        name="Responses",
-        provider=ProviderFormat.OPENAI_RESPONSES,
-        model="gpt-5.1",
-        secret_reference="connection-responses",
-    )
-
-    chunks = [
-        chunk
-        async for chunk in stream_chat(
-            connection,
-            [ChatMessage(role="user", content="Create a checklist.")],
-            completion=fake_completion,
-        )
-    ]
-
-    assert captured_request["stream"] is True
-    assert captured_request["model"] == "openai/gpt-5.1"
-    assert chunks == ["Here is ", "the checklist."]
-
-
-@pytest.mark.anyio
-async def test_development_mode_writes_one_streaming_request_diagnostic_file(
-    tmp_path, monkeypatch
-) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    monkeypatch.setenv("DEBUG", "true")
-
-    async def fake_completion(**request: object) -> object:
-        async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Here is "}}]}
-            yield {"choices": [{"delta": {"content": "the checklist."}}]}
-
-        return chunks()
-
-    connection = ProviderConnection(
-        name="Responses",
-        provider=ProviderFormat.OPENAI_RESPONSES,
-        model="gpt-5.1",
-        secret_reference="sk-request-secret",
-    )
-
-    chunks = [
-        chunk
-        async for chunk in stream_chat(
-            connection,
-            [ChatMessage(role="user", content="Create a checklist.")],
-            completion=fake_completion,
-        )
-    ]
-    diagnostic = read_single_llm_request_diagnostic(tmp_path)
-
-    assert chunks == ["Here is ", "the checklist."]
-    assert diagnostic["stream"] is True
-
-
-@pytest.mark.anyio
-async def test_development_request_diagnostic_omits_api_key_and_secret_values(
-    tmp_path, monkeypatch
-) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    monkeypatch.setenv("DEBUG", "true")
-
-    async def fake_completion(**request: object) -> dict[str, object]:
-        return {
-            "choices": [
-                {
-                    "message": {
-                        "content": "Here is the checklist.",
-                        "role": "assistant",
-                    },
-                }
-            ]
-        }
-
-    connection = ProviderConnection(
-        name="Responses",
-        provider=ProviderFormat.OPENAI_RESPONSES,
-        model="gpt-5.1",
-        secret_reference="sk-provider-secret",
-    )
-    tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "create_checklist",
-                "description": "Uses api_key=sk-tool-secret when configured.",
-            },
-        }
-    ]
-
-    await complete_chat(
-        connection,
-        [ChatMessage(role="user", content="authorization=Bearer sk-message-secret")],
-        completion=fake_completion,
-        tools=tools,
-    )
-
-    rendered = next(
-        (tmp_path / "logs" / "llm-requests").glob("llm-request-*.json")
-    ).read_text()
-
-    assert "api_key" not in rendered
-    assert "sk-provider-secret" not in rendered
-    assert "sk-tool-secret" not in rendered
-    assert "sk-message-secret" not in rendered
-
-
-@pytest.mark.anyio
-async def test_non_development_mode_skips_request_diagnostic_file(
-    tmp_path, monkeypatch
-) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    monkeypatch.delenv("DEBUG", raising=False)
-
-    async def fake_completion(**request: object) -> dict[str, object]:
-        return {
-            "choices": [
-                {
-                    "message": {
-                        "content": "Here is the checklist.",
-                        "role": "assistant",
-                    },
-                }
-            ]
-        }
-
-    connection = ProviderConnection(
-        name="Responses",
-        provider=ProviderFormat.OPENAI_RESPONSES,
-        model="gpt-5.1",
-        secret_reference="sk-request-secret",
-    )
-
-    await complete_chat(
-        connection,
-        [ChatMessage(role="user", content="Create a checklist.")],
-        completion=fake_completion,
-    )
-
-    assert not (tmp_path / "logs" / "llm-requests").exists()
-
-
-def test_normalize_system_messages_keeps_multiple_system_messages_for_openai() -> None:
-    messages = [
-        {"role": "system", "content": "Base prompt."},
-        {"role": "system", "content": "Configured prompt."},
-        {"role": "user", "content": "Hello."},
-    ]
-
-    assert normalize_system_messages(messages, ProviderFormat.OPENAI) == messages
-
-
-def test_normalize_system_messages_converts_additional_system_messages_for_anthropic() -> (
-    None
-):
-    messages = [
-        {"role": "system", "content": "Base prompt."},
-        {"role": "system", "content": "Configured prompt."},
-        {"role": "system", "content": "Project prompt."},
-        {"role": "user", "content": "Hello."},
-    ]
-
-    assert normalize_system_messages(messages, ProviderFormat.ANTHROPIC) == [
-        {"role": "system", "content": "Base prompt."},
-        {"role": "user", "content": "Configured prompt."},
-        {"role": "user", "content": "Project prompt."},
-        {"role": "user", "content": "Hello."},
-    ]

package/backend/tests/test_logging.py

@@ -1,212 +0,0 @@
-import logging
-import sys
-
-from flowent.logging import (
-    LITELLM_LOGGER_NAMES,
-    TRACE_LEVEL,
-    configure_litellm_logging,
-    configure_logging,
-    ensure_logging_configured,
-    redact_log_value,
-    sanitize_diagnostic_value,
-)
-
-
-def test_logging_creates_run_file_under_data_logs(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-
-    log_file = configure_logging()
-
-    assert log_file.parent == tmp_path / "logs"
-    assert log_file.name.startswith("flowent-")
-    assert log_file.suffix == ".log"
-    assert log_file.is_file()
-
-
-def test_file_logging_accepts_trace_and_console_uses_mode_levels(
-    tmp_path, monkeypatch
-) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    monkeypatch.setenv("DEBUG", "False")
-
-    log_file = configure_logging()
-    handlers = logging.getLogger().handlers
-    file_handler = next(
-        handler for handler in handlers if isinstance(handler, logging.FileHandler)
-    )
-    console_handler = next(
-        handler for handler in handlers if not isinstance(handler, logging.FileHandler)
-    )
-
-    assert file_handler.level == TRACE_LEVEL
-    assert console_handler.level == logging.INFO
-
-    logging.getLogger("flowent.test").log(TRACE_LEVEL, "trace-only detail")
-    for handler in logging.getLogger().handlers:
-        handler.flush()
-
-    assert "trace-only detail" in log_file.read_text()
-
-    monkeypatch.setenv("DEBUG", "True")
-    configure_logging()
-    console_handler = next(
-        handler
-        for handler in logging.getLogger().handlers
-        if not isinstance(handler, logging.FileHandler)
-    )
-
-    assert console_handler.level == logging.DEBUG
-
-
-def test_logging_prunes_old_run_logs(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    logs = tmp_path / "logs"
-    logs.mkdir(parents=True)
-    for index in range(6):
-        (logs / f"flowent-20260101-00000{index}-1.log").write_text(str(index))
-
-    configure_logging()
-
-    files = sorted(log.name for log in logs.glob("flowent-*.log"))
-    assert len(files) == 5
-    assert "flowent-20260101-000000-1.log" not in files
-
-
-def test_logging_path_follows_flowent_data_dir(tmp_path, monkeypatch) -> None:
-    data_dir = tmp_path / "custom-flowent"
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(data_dir))
-
-    log_file = configure_logging()
-
-    assert log_file.parent == data_dir / "logs"
-
-
-def test_logging_redacts_full_api_key_but_keeps_context(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    log_file = configure_logging()
-
-    logging.getLogger("flowent.test").log(
-        TRACE_LEVEL,
-        "provider=OpenAI model=gpt-5 output=hello api_key=sk-secret-value",
-    )
-    for handler in logging.getLogger().handlers:
-        handler.flush()
-
-    rendered = log_file.read_text()
-
-    assert "provider=OpenAI" in rendered
-    assert "model=gpt-5" in rendered
-    assert "output=hello" in rendered
-    assert "sk-secret-value" not in rendered
-    assert "api_key=[REDACTED]" in rendered
-    assert redact_log_value("authorization=Bearer sk-secret-value") == (
-        "authorization=[REDACTED]"
-    )
-
-
-def test_diagnostic_sanitizer_removes_secret_fields_and_values() -> None:
-    sanitized = sanitize_diagnostic_value(
-        {
-            "api_key": "sk-root-secret",
-            "messages": [
-                {
-                    "role": "user",
-                    "content": "authorization=Bearer sk-message-secret",
-                }
-            ],
-            "tools": [
-                {
-                    "function": {
-                        "name": "send_message",
-                        "description": "Needs api_key=sk-tool-secret.",
-                    }
-                }
-            ],
-        }
-    )
-
-    rendered = str(sanitized)
-
-    assert "api_key" not in rendered
-    assert "sk-root-secret" not in rendered
-    assert "sk-message-secret" not in rendered
-    assert "sk-tool-secret" not in rendered
-
-
-def test_direct_main_app_import_creates_data_log_file(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    sys.modules.pop("flowent.main", None)
-
-    try:
-        __import__("flowent.main")
-    finally:
-        sys.modules.pop("flowent.main", None)
-
-    files = sorted((tmp_path / "logs").glob("flowent-*.log"))
-    assert len(files) == 1
-
-
-def test_create_app_creates_data_log_file(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-
-    from flowent.main import create_app
-
-    create_app(serve_frontend=False)
-
-    files = sorted((tmp_path / "logs").glob("flowent-*.log"))
-    assert len(files) == 1
-
-
-def test_create_app_reuses_logging_handlers(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-
-    from flowent.main import create_app
-
-    create_app(serve_frontend=False)
-    create_app(serve_frontend=False)
-
-    handlers = logging.getLogger().handlers
-    file_handlers = [
-        handler for handler in handlers if isinstance(handler, logging.FileHandler)
-    ]
-    console_handlers = [
-        handler for handler in handlers if not isinstance(handler, logging.FileHandler)
-    ]
-    files = sorted((tmp_path / "logs").glob("flowent-*.log"))
-
-    assert len(file_handlers) == 1
-    assert len(console_handlers) == 1
-    assert len(files) == 1
-
-
-def test_any_logging_path_follows_flowent_data_dir(tmp_path, monkeypatch) -> None:
-    data_dir = tmp_path / "custom-flowent"
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(data_dir))
-
-    log_file = ensure_logging_configured()
-
-    assert log_file.parent == data_dir / "logs"
-
-
-def test_litellm_debug_logs_use_flowent_handlers(tmp_path, monkeypatch, capsys) -> None:
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path))
-    monkeypatch.delenv("LITELLM_LOG", raising=False)
-
-    log_file = configure_logging()
-    import litellm  # noqa: F401
-
-    configure_litellm_logging()
-    logging.getLogger("LiteLLM").debug("stream chunk detail")
-    for handler in logging.getLogger().handlers:
-        handler.flush()
-
-    captured = capsys.readouterr()
-    litellm_handlers = [
-        handler
-        for logger_name in LITELLM_LOGGER_NAMES
-        for handler in logging.getLogger(logger_name).handlers
-    ]
-
-    assert litellm_handlers == []
-    assert "stream chunk detail" not in captured.err
-    assert "stream chunk detail" in log_file.read_text()