* such as Ollama, OpenAI, and Google Gemini.
 *
 * In addition to low-level chat operations, this interface defines
 * high-level RAG workflow methods that allow each provider to optimize
 * prompt construction, parameter tuning, and response parsing.
 */
public interface LlmClient {

    /**
     * Performs a chat completion request.
     *
     * @param request the chat request containing messages and parameters

        // Assert
        assertNotNull(handle);
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
        // We cannot directly assert the 'opened' field as it's private, but successful construction implies it.
    }

    @Test
    void constructor_shouldHandleNullServerSuccessfully() throws IOException {
        // Arrange
        String server = null;
        int access = 123;

fi

echo ""
echo "--- Format hint tests ---"

# Test that format hints are properly constructed
# This is a logical test of the script structure
echo -n "Testing: format hint construction... "
if grep -q 'format_hint=""' "${GENERATE_THUMBNAIL}" && \
   grep -q 'image/gif.*gif:' "${GENERATE_THUMBNAIL}" && \
   grep -q 'image/tiff.*tiff:' "${GENERATE_THUMBNAIL}"; then
    echo -e "${GREEN}PASSED${NC}"

   * ConcurrentModificationException}, and guarantees to traverse elements as they existed upon
   * construction of the iterator, and may (but is not guaranteed to) reflect any modifications
   * subsequent to construction.
   *
   * @return an iterator over the elements in this queue in proper sequence
   */
  @CanIgnoreReturnValue
  @Override

   * will never throw {@link ConcurrentModificationException}, and guarantees to traverse elements
   * as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect
   * any modifications subsequent to construction.
   *
   * @return an iterator over the elements in this queue
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override

    checkArgument(isFinite(x1) && isFinite(y1));
    return new LinearTransformationBuilder(x1, y1);
  }

  /**
   * This is an intermediate stage in the construction process. It is returned by {@link
   * LinearTransformation#mapping}. You almost certainly don't want to keep instances around, but
   * instead use method chaining. This represents a single point mapping, i.e. a mapping between one

     * Creates a new dictionary manager with an empty creator list.
     */
    public DictionaryManager() {
        // Default constructor
    }

    /**
     * Initializes the dictionary manager after construction.
     * Sets up the relationship between this manager and all registered creators.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {

- **Strategy**: `CrawlerClient`, `Extractor`, `Transformer` - pluggable implementations
- **Builder**: `RequestDataBuilder`, `ExtractorBuilder` - fluent construction
- **Template Method**: `AbstractCrawlerClient`, `AbstractExtractor` - common logic with overrides
- **DI**: LastaFlute container with `@Resource` and XML config

### Core Principles

        when(this.mechContext.getFlags()).thenReturn(0x1234);
        when(this.mechContext.initSecContext(any(byte[].class), eq(0), eq(0))).thenReturn(new byte[] { 0x01, 0x02 });

        // Act: len==0 triggers initial token construction
        byte[] out = ctx.initSecContext(null, 0, 0);

        // Assert: returns a SPNEGO token (opaque here but non-null/non-empty)
        assertNotNull(out);
        assertTrue(out.length > 0);

        assertEquals(2048, negotiationWithLargeBuffers.getResponseRaw().length);
    }

    @Test
    @DisplayName("Fields should be immutable after construction")
    void testImmutability() {
        // Get references to the objects
        SmbNegotiationRequest originalRequest = negotiation.getRequest();