Merge pull request #14 from lucaromagnoli/fix/llmtypes

Remove business logic coupling from core types

Author: lucaromagnoli

.github/workflows/ci.yml

@@ -19,6 +19,51 @@ jobs:
     - name: Checkout code
       uses: actions/checkout@v4
 
+    # Cache vcpkg packages (Windows)
+    - name: Cache vcpkg packages
+      if: matrix.os == 'windows-latest'
+      uses: actions/cache@v4
+      with:
+        path: |
+          ${{ github.workspace }}/vcpkg
+          ${{ github.workspace }}/vcpkg_installed
+        key: vcpkg-${{ matrix.os }}-${{ hashFiles('vcpkg.json') }}
+        restore-keys: |
+          vcpkg-${{ matrix.os }}-
+
+    # Cache CMake build directory
+    - name: Cache CMake build
+      uses: actions/cache@v4
+      with:
+        path: |
+          build
+          !build/tests/llmcpp_tests
+          !build/examples
+        key: cmake-${{ matrix.os }}-${{ matrix.build_type }}-${{ hashFiles('CMakeLists.txt', '**/CMakeLists.txt') }}
+        restore-keys: |
+          cmake-${{ matrix.os }}-${{ matrix.build_type }}-
+
+    # Cache package manager dependencies
+    - name: Cache Homebrew (macOS)
+      if: matrix.os == 'macos-latest'
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/Library/Caches/Homebrew
+          /opt/homebrew/Cellar
+        key: homebrew-${{ hashFiles('.github/workflows/ci.yml') }}
+        restore-keys: homebrew-
+
+    - name: Cache apt packages (Linux)
+      if: matrix.os == 'ubuntu-22.04'
+      uses: actions/cache@v4
+      with:
+        path: |
+          /var/cache/apt
+          /var/lib/apt
+        key: apt-${{ hashFiles('.github/workflows/ci.yml') }}
+        restore-keys: apt-
+
     - name: Install dependencies (macOS)
       if: matrix.os == 'macos-latest'
       run: brew install cmake ninja
@@ -63,7 +108,7 @@ jobs:
 
     - name: Build
       timeout-minutes: 15
-      run: cmake --build build --config ${{ matrix.build_type }}
+      run: cmake --build build --config ${{ matrix.build_type }} --parallel
 
     - name: Test
       working-directory: build

include/core/LLMTypes.h

@@ -10,72 +10,6 @@ using json = nlohmann::json;
 // Input type using standard C++ vectors instead of JUCE StringArray
 using LLMInput = std::vector<std::string>;
 
-/**
- * @brief Common schema names for structured outputs
- *
- * Provides type-safe schema naming to prevent typos and improve maintainability.
- * These correspond to common use cases in AI applications.
- */
-enum class ResponsesSchemaName {
-    SentimentAnalysis,  // sentiment_analysis
-    DataExtraction,     // data_extraction
-    Classification,     // classification
-    EntityExtraction,   // entity_extraction
-    ContentAnalysis,    // content_analysis
-    DocumentAnalysis,   // document_analysis
-    ReviewAnalysis,     // review_analysis
-    WeatherInfo,        // weather_info
-    ProductInfo,        // product_info
-    UserProfile,        // user_profile
-    ImageAnalysis,      // image_analysis
-    TextSummary,        // text_summary
-    Translation,        // translation
-    MathSolution,       // math_solution
-    CodeAnalysis,       // code_analysis
-    Custom              // For user-defined schema names
-};
-
-/**
- * @brief Convert ResponsesSchemaName enum to string
- */
-inline std::string toString(ResponsesSchemaName schemaName) {
-    switch (schemaName) {
-        case ResponsesSchemaName::SentimentAnalysis:
-            return "sentiment_analysis";
-        case ResponsesSchemaName::DataExtraction:
-            return "data_extraction";
-        case ResponsesSchemaName::Classification:
-            return "classification";
-        case ResponsesSchemaName::EntityExtraction:
-            return "entity_extraction";
-        case ResponsesSchemaName::ContentAnalysis:
-            return "content_analysis";
-        case ResponsesSchemaName::DocumentAnalysis:
-            return "document_analysis";
-        case ResponsesSchemaName::ReviewAnalysis:
-            return "review_analysis";
-        case ResponsesSchemaName::WeatherInfo:
-            return "weather_info";
-        case ResponsesSchemaName::ProductInfo:
-            return "product_info";
-        case ResponsesSchemaName::UserProfile:
-            return "user_profile";
-        case ResponsesSchemaName::ImageAnalysis:
-            return "image_analysis";
-        case ResponsesSchemaName::TextSummary:
-            return "text_summary";
-        case ResponsesSchemaName::Translation:
-            return "translation";
-        case ResponsesSchemaName::MathSolution:
-            return "math_solution";
-        case ResponsesSchemaName::CodeAnalysis:
-            return "code_analysis";
-        case ResponsesSchemaName::Custom:
-            return "custom_schema";
-    }
-    return "unknown_schema";
-}
-
 /// Represents the configuration for the LLM
 struct LLMRequestConfig {
     std::string client;

include/openai/OpenAISchemaBuilder.h

@@ -87,40 +87,3 @@ class OpenAIChatSchemaBuilder {
     std::string schemaName_;
     JsonSchemaBuilder schema_;
 };
-
-/**
- * @brief Common schema patterns for OpenAI APIs
- *
- * Provides pre-built schemas for common use cases.
- */
-class OpenAISchemaPatterns {
-   public:
-    // Sentiment analysis schema
-    static OpenAI::TextOutputConfig sentimentAnalysis();
-
-    // Data extraction schema
-    static OpenAI::TextOutputConfig dataExtraction(const std::vector<std::string>& fields);
-
-    // Classification schema
-    static OpenAI::TextOutputConfig classification(const std::vector<std::string>& categories);
-
-    // Summary schema
-    static OpenAI::TextOutputConfig summary(int maxLength = 500);
-
-    // Key-value extraction
-    static OpenAI::TextOutputConfig keyValueExtraction();
-
-    // Boolean decision
-    static OpenAI::TextOutputConfig booleanDecision(const std::string& question);
-
-    // Structured entity extraction
-    static OpenAI::TextOutputConfig entityExtraction();
-
-    // Translation schema
-    static OpenAI::TextOutputConfig translation(const std::string& targetLanguage);
-
-    // Chat completions patterns
-    static json chatJsonMode();
-    static json chatClassification(const std::vector<std::string>& categories);
-    static json chatSentiment();
-};

src/openai/OpenAISchemaBuilder.cpp

@@ -73,132 +73,3 @@ json OpenAIChatSchemaBuilder::build() const {
     }
     return json{{"type", "text"}};  // fallback
 }
-
-// OpenAISchemaPatterns implementation
-OpenAI::TextOutputConfig OpenAISchemaPatterns::sentimentAnalysis() {
-    return OpenAIResponsesSchemaBuilder("sentiment_analysis")
-        .description("Analyze the sentiment of the given text")
-        .property("sentiment", JsonSchemaBuilder::stringEnum({"positive", "negative", "neutral"}))
-        .property("confidence", JsonSchemaBuilder::number().minimum(0).maximum(1).description(
-                                    "Confidence score from 0 to 1"))
-        .required({"sentiment", "confidence"})
-        .build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::dataExtraction(
-    const std::vector<std::string>& fields) {
-    auto builder = OpenAIResponsesSchemaBuilder("data_extraction")
-                       .description("Extract structured data from text");
-
-    for (const auto& field : fields) {
-        builder.property(field, JsonSchemaBuilder::string().description("Extracted " + field));
-    }
-
-    builder.required(fields);
-    return builder.build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::classification(
-    const std::vector<std::string>& categories) {
-    return OpenAIResponsesSchemaBuilder("classification")
-        .description("Classify the input into one of the predefined categories")
-        .property("category", JsonSchemaBuilder::stringEnum(categories))
-        .property("confidence", JsonSchemaBuilder::number().minimum(0).maximum(1))
-        .property("reasoning", JsonSchemaBuilder::string().description(
-                                   "Brief explanation of the classification"))
-        .required({"category", "confidence"})
-        .build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::summary(int maxLength) {
-    return OpenAIResponsesSchemaBuilder("summary")
-        .description("Generate a concise summary of the input text")
-        .property("summary",
-                  JsonSchemaBuilder::string().maxLength(maxLength).description("Concise summary"))
-        .property(
-            "key_points",
-            JsonSchemaBuilder::arrayOf(JsonSchemaBuilder::string()).description("Main points"))
-        .property("word_count",
-                  JsonSchemaBuilder::integer().minimum(1).description("Number of words in summary"))
-        .required({"summary", "key_points", "word_count"})
-        .build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::keyValueExtraction() {
-    return OpenAIResponsesSchemaBuilder("key_value_extraction")
-        .description("Extract key-value pairs from the text")
-        .property("extracted_data",
-                  JsonSchemaBuilder::object().additionalProperties(JsonSchemaBuilder::string()))
-        .property("metadata", JsonSchemaBuilder::object()
-                                  .property("extraction_confidence",
-                                            JsonSchemaBuilder::number().minimum(0).maximum(1))
-                                  .property("total_pairs", JsonSchemaBuilder::integer().minimum(0)))
-        .required({"extracted_data", "metadata"})
-        .build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::booleanDecision(const std::string& question) {
-    return OpenAIResponsesSchemaBuilder("boolean_decision")
-        .description("Make a yes/no decision based on: " + question)
-        .property("decision",
-                  JsonSchemaBuilder::boolean().description("True for yes, false for no"))
-        .property("reasoning",
-                  JsonSchemaBuilder::string().description("Explanation for the decision"))
-        .property("confidence", JsonSchemaBuilder::number().minimum(0).maximum(1))
-        .required({"decision", "reasoning", "confidence"})
-        .build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::entityExtraction() {
-    auto entitySchema =
-        JsonSchemaBuilder::object()
-            .property("text", JsonSchemaBuilder::string().description("The extracted entity text"))
-            .property("type", JsonSchemaBuilder::stringEnum(
-                                  {"PERSON", "ORGANIZATION", "LOCATION", "DATE", "MONEY", "OTHER"}))
-            .property("start_pos",
-                      JsonSchemaBuilder::integer().minimum(0).description("Start position in text"))
-            .property("end_pos",
-                      JsonSchemaBuilder::integer().minimum(0).description("End position in text"))
-            .required({"text", "type"});
-
-    return OpenAIResponsesSchemaBuilder("entity_extraction")
-        .description("Extract named entities from the text")
-        .property("entities", JsonSchemaBuilder::arrayOf(entitySchema))
-        .property("entity_count", JsonSchemaBuilder::integer().minimum(0))
-        .required({"entities", "entity_count"})
-        .build();
-}
-
-OpenAI::TextOutputConfig OpenAISchemaPatterns::translation(const std::string& targetLanguage) {
-    return OpenAIResponsesSchemaBuilder("translation")
-        .description("Translate text to " + targetLanguage)
-        .property("translated_text", JsonSchemaBuilder::string().description("The translated text"))
-        .property("source_language",
-                  JsonSchemaBuilder::string().description("Detected source language"))
-        .property("target_language", JsonSchemaBuilder::string().constValue(targetLanguage))
-        .property("confidence", JsonSchemaBuilder::number().minimum(0).maximum(1))
-        .required({"translated_text", "source_language", "target_language", "confidence"})
-        .build();
-}
-
-// Chat completions patterns
-json OpenAISchemaPatterns::chatJsonMode() { return OpenAIChatSchemaBuilder().jsonMode().build(); }
-
-json OpenAISchemaPatterns::chatClassification(const std::vector<std::string>& categories) {
-    auto schema = JsonSchemaBuilder::object()
-                      .property("category", JsonSchemaBuilder::stringEnum(categories))
-                      .property("confidence", JsonSchemaBuilder::number().minimum(0).maximum(1))
-                      .required({"category", "confidence"});
-
-    return OpenAIChatSchemaBuilder().jsonSchema("classification", schema).build();
-}
-
-json OpenAISchemaPatterns::chatSentiment() {
-    auto schema = JsonSchemaBuilder::object()
-                      .property("sentiment",
-                                JsonSchemaBuilder::stringEnum({"positive", "negative", "neutral"}))
-                      .property("confidence", JsonSchemaBuilder::number().minimum(0).maximum(1))
-                      .required({"sentiment", "confidence"});
-
-    return OpenAIChatSchemaBuilder().jsonSchema("sentiment", schema).build();
-}

tests/unit/test_json_schema_builder.cpp

@@ -174,49 +174,6 @@ TEST_CASE("OpenAI Chat Completions schema builder", "[schema][openai][chat]") {
     }
 }
 
-TEST_CASE("OpenAI schema patterns", "[schema][openai][patterns]") {
-    SECTION("Sentiment analysis pattern") {
-        auto config = OpenAISchemaPatterns::sentimentAnalysis();
-        auto configJson = config.toJson();
-
-        REQUIRE(configJson["format"]["name"] == "sentiment_analysis");
-        auto schema = configJson["format"]["schema"];
-        REQUIRE(schema["properties"].contains("sentiment"));
-        REQUIRE(schema["properties"].contains("confidence"));
-    }
-
-    SECTION("Classification pattern") {
-        std::vector<std::string> categories = {"technology", "science", "arts", "sports"};
-        auto config = OpenAISchemaPatterns::classification(categories);
-        auto configJson = config.toJson();
-
-        auto schema = configJson["format"]["schema"];
-        REQUIRE(schema["properties"]["category"]["enum"].size() == 4);
-        REQUIRE(schema["properties"]["category"]["enum"][0] == "technology");
-    }
-
-    SECTION("Data extraction pattern") {
-        std::vector<std::string> fields = {"name", "company", "position"};
-        auto config = OpenAISchemaPatterns::dataExtraction(fields);
-        auto configJson = config.toJson();
-
-        auto schema = configJson["format"]["schema"];
-        REQUIRE(schema["properties"].contains("name"));
-        REQUIRE(schema["properties"].contains("company"));
-        REQUIRE(schema["properties"].contains("position"));
-        REQUIRE(schema["required"].size() == 3);
-    }
-
-    SECTION("Chat patterns") {
-        auto jsonMode = OpenAISchemaPatterns::chatJsonMode();
-        REQUIRE(jsonMode["type"] == "json_object");
-
-        auto chatSentiment = OpenAISchemaPatterns::chatSentiment();
-        REQUIRE(chatSentiment["type"] == "json_schema");
-        REQUIRE(chatSentiment["json_schema"]["name"] == "sentiment");
-    }
-}
-
 TEST_CASE("Schema integration examples", "[schema][integration]") {
     SECTION("Complex nested schema for content analysis") {
         auto entitySchema =