func tryStreamableHTTPTransport(ctx context.Context, cancel context.CancelFunc, url string, headers map[string]string, httpClient *http.Client) (*Connection, error) {
    // Create MCP client
    client := newMCPClient()
    
    // Create streamable HTTP transport
    transport := &sdk.StreamableClientTransport{
        Endpoint:   url,
        HTTPClient: httpClient,
        MaxRetries: 0, // Don't retry on failure - we'll try other transports
    }
    
    // Try to connect with a timeout
    connectCtx, connectCancel := context.WithTimeout(ctx, 5*time.Second)
    defer connectCancel()
    
    session, err := client.Connect(connectCtx, transport, nil)
    if err != nil {
        return nil, fmt.Errorf("streamable HTTP transport connect failed: %w", err)
    }
    
    conn := newHTTPConnection(ctx, cancel, client, session, url, headers, httpClient, HTTPTransportStreamable)
    
    logger.LogInfo("backend", "Streamable HTTP transport connected successfully")
    logConn.Printf("Connected with streamable HTTP transport")
    return conn, nil
}

func trySSETransport(ctx context.Context, cancel context.CancelFunc, url string, headers map[string]string, httpClient *http.Client) (*Connection, error) {
    // Create MCP client
    client := newMCPClient()
    
    // Create SSE transport
    transport := &sdk.SSEClientTransport{
        Endpoint:   url,
        HTTPClient: httpClient,
    }
    
    // Try to connect with a timeout
    connectCtx, connectCancel := context.WithTimeout(ctx, 5*time.Second)
    defer connectCancel()
    
    session, err := client.Connect(connectCtx, transport, nil)
    if err != nil {
        return nil, fmt.Errorf("SSE transport connect failed: %w", err)
    }
    
    conn := newHTTPConnection(ctx, cancel, client, session, url, headers, httpClient, HTTPTransportSSE)
    
    logger.LogInfo("backend", "SSE transport connected successfully")
    logConn.Printf("Connected with SSE transport")
    return conn, nil
}

// transportConnector defines the interface for creating SDK transports
type transportConnector interface {
    createTransport(url string, httpClient *http.Client) sdk.Transport
    transportType() HTTPTransportType
    transportName() string
}

// tryTransport is a generic function to attempt connection with any transport type
func tryTransport(ctx context.Context, cancel context.CancelFunc, url string, headers map[string]string, httpClient *http.Client, connector transportConnector) (*Connection, error) {
    // Create MCP client
    client := newMCPClient()
    
    // Create transport using the connector
    transport := connector.createTransport(url, httpClient)
    
    // Try to connect with a timeout
    connectCtx, connectCancel := context.WithTimeout(ctx, 5*time.Second)
    defer connectCancel()
    
    session, err := client.Connect(connectCtx, transport, nil)
    if err != nil {
        return nil, fmt.Errorf("%s transport connect failed: %w", connector.transportName(), err)
    }
    
    conn := newHTTPConnection(ctx, cancel, client, session, url, headers, httpClient, connector.transportType())
    
    logger.LogInfo("backend", "%s transport connected successfully", connector.transportName())
    logConn.Printf("Connected with %s transport", connector.transportName())
    return conn, nil
}

// Streamable HTTP connector
type streamableConnector struct{}
func (s streamableConnector) createTransport(url string, httpClient *http.Client) sdk.Transport {
    return &sdk.StreamableClientTransport{
        Endpoint:   url,
        HTTPClient: httpClient,
        MaxRetries: 0,
    }
}
func (s streamableConnector) transportType() HTTPTransportType { return HTTPTransportStreamable }
func (s streamableConnector) transportName() string { return "streamable HTTP" }

// Then in NewHTTPConnection:
conn, err := tryTransport(ctx, cancel, url, headers, httpClient, streamableConnector{})